Dataset Viewer
Auto-converted to Parquet Duplicate
question_id
stringlengths
22
31
question_type
stringclasses
1 value
description
stringlengths
30
130
content
dict
environment
dict
answer
dict
test
dict
scoring_config
dict
MSB_einsteintoolkit_Cactus_pr1
multi_swe_bench
Add missing LinearExtrapBnd.c in CactusExamples/SampleBoundary (einsteintoolkit/Cactus#1)
{ "org": "einsteintoolkit", "repo": "Cactus", "pr_number": 1, "issue_title": "Add missing LinearExtrapBnd.c in CactusExamples/SampleBoundary", "issue_body": "This PR adds the missing source file LinearExtrapBnd.c to complete the CactusExamples/SampleBoundary thorn implementation.", "base_commit": "HEAD", "resolved_issues": [ { "number": 1, "title": "Implement the full functionality of SampleBoundary", "body": "Please implement the full functionality of `SampleBoundary` by finishing the code in `LinearExtrapBnd.c`.\n\n## Thorn Information:\n- Name: SampleBoundary\n- Target file: LinearExtrapBnd.c\n\n## Interface Definition in interface.ccl:\n\n## Schedule Definition in schedule.ccl:\n\n## Parameters Definition in param.ccl:\n\n## Configuration Definition in configuration.ccl:\n\n## Documentation Context in readme.md and doc/documentation.tex\n\n## Related Code Context in src folder\n\n" } ], "commits": [], "diff_url": "", "patch_url": "", "html_url": "", "created_at": "", "merged_at": "" }
{ "env_type": "docker", "docker_image": "mswebench/einsteintoolkit_m_cactus:pr-1", "working_directory": "/testbed", "needs_build": true }
{ "fix_patch": "diff --git a/arrangements/CactusExamples/SampleBoundary/src/LinearExtrapBnd.c b/arrangements/CactusExamples/SampleBoundary/src/LinearExtrapBnd.c\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/arrangements/CactusExamples/SampleBoundary/src/LinearExtrapBnd.c\n@@ -0,0 +1,246 @@\n+ /*@@\n+ @file LinearExtrapBnd.c\n+ @date 24 Jan 2003\n+ @author David Rideout\n+ @desc\n+ Function which is registered as handling Carsten Gundlach's \n+ \"linear_extrap_one_bndry\" boundary condition\n+ @enddesc\n+ @history\n+ @hdate \n+ @hauthor \n+ @hdesc \n+ @endhistory\n+ @version $Id$\n+ @@*/\n+\n+#include \"cctk.h\"\n+\n+#include \"util_Table.h\"\n+\n+/* the rcs ID and its dummy function to use it */\n+static const char *rcsid = \"$Header$\";\n+CCTK_FILEVERSION(CactusExamples_SampleBoundary_LinearExtrapBnd_c);\n+\n+/* #define DEBUG */\n+\n+/********************************************************************\n+ ********************* Local Data Types ***********************\n+ ********************************************************************/\n+\n+/********************************************************************\n+ ********************* External Routine Prototypes ******************\n+ ********************************************************************/\n+\n+void CCTK_FCALL CCTK_FNAME(Linear_extrap_one_bndry)(int *doBC, const int *lsh, \n+ CCTK_REAL *var_ptr);\n+\n+int BndLinExtrap (const cGH *GH, int num_vars, int *vars, int *faces, \n+ int *widths, int *tables);\n+\n+/********************************************************************\n+ ******************** Scheduled Routines ***********************\n+ ********************************************************************/\n+\n+\n+/********************************************************************\n+ ******************** External Routines ************************\n+ ********************************************************************/\n+\n+/*@@\n+ @routine BndLinExtrap\n+ @date 24 Jan 2003\n+ @author David Rideout\n+ @desc\n+ Apply linear extrapolation boundary condition to a\n+ group of grid functions given by their indices.\n+ This routine is registered to handle the linear\n+ extrapolation boundary condition.\n+ Can only handle 3D grid functions.\n+\n+ All symmetries are ignored for now -- the symmetry bcs must \n+ overwrite the output of this bc where necessary\n+ @enddesc\n+\n+ @var GH\n+ @vdesc Pointer to CCTK grid hierarchy\n+ @vtype const cGH *\n+ @vio in\n+ @endvar\n+ @var num_vars\n+ @vdesc number of variables passed in through vars[]\n+ @vtype int\n+ @vio in\n+ @endvar\n+ @var var_indices\n+ @vdesc array of variable indicies to which to apply this boundary \n+ condition\n+ @vtype int *\n+ @vio in\n+ @endvar\n+ @var faces\n+ @vdesc array of set of faces to which to apply the bc\n+ @vtype int\n+ @vio in\n+ @endvar\n+ @var widths\n+ @vdesc array of boundary widths for each variable\n+ @vtype int\n+ @vio in\n+ @endvar\n+ @var table_handles\n+ @vdesc array of table handles which hold extra arguments\n+ @vtype int\n+ @vio in\n+ @endvar\n+\n+ @calls CCTK_GroupIndexFromVarI\n+ CCTK_GroupDimI\n+ CCTK_VarTypeI\n+\n+ Linear_extrap_one_bndry\n+ @history\n+ @hdate \n+ @hauthor \n+ @hdesc \n+ @endhistory\n+\n+ @returntype int\n+ @returndesc\n+ each bit of return value indicates a possible error code, as follows:\n+ 0 for success\n+ -1 invalid faces specification\n+ -2 unsupported staggering\n+ -4 boundary width != 1\n+ -8 potentially valid table handle\n+ -16 dimension is not supported\n+ -32 possibly called with a grid scalar\n+ @endreturndesc\n+@@*/\n+\n+int BndLinExtrap (const cGH *GH, int num_vars, int *vars, int *faces, \n+ int *widths, int *tables)\n+{\n+ int i, j, gi, gtype, dim, retval, err;\n+ int doBC[6];\n+ const int *lsh, *bbox;\n+ CCTK_INT symtable;\n+ CCTK_INT symbnd[6];\n+ CCTK_INT is_physical[6];\n+ CCTK_REAL *var_ptr;\n+ cGroupDynamicData group_data;\n+\n+ retval = 0;\n+\n+#ifdef DEBUG\n+ printf(\"calling BndLinExtrap at iter %d\\n\", GH->cctk_iteration);\n+#endif\n+\n+ /* loop through variables, one at a time (since this is all that \n+ Linear_extrap_one_bndry can handle) */\n+ for (i=0; i<num_vars; ++i) {\n+\n+ /* Check to see if faces specification is valid */\n+ if (faces[i] != CCTK_ALL_FACES)\n+ {\n+ CCTK_VWarn(1, __LINE__, __FILE__, CCTK_THORNSTRING,\n+ \"Faces specification %d for LinExtrap boundary conditions on \"\n+ \"%s is not implemented yet. \"\n+ \"Not applying bc.\", faces[i],\n+ CCTK_VarName(vars[i]));\n+ retval |= 1;\n+ }\n+\n+ /* Check to see if the boundary width might be something other than one */\n+ if (widths[i] != 1)\n+ {\n+ CCTK_VWarn(1, __LINE__, __FILE__, CCTK_THORNSTRING,\n+ \"LinExtrapBnd does not handle boundary widths other than one.\"\n+ \" Assuming boundary width of one on all faces.\");\n+ retval |= 4;\n+ }\n+\n+ /* Ignore table handles */\n+ if (tables[i] >= 0) \n+ {\n+ CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,\n+ \"Possibly valid table handle. LinExtrapBnd ignores \"\n+ \"information stored in tables.\");\n+ retval |= 8;\n+ }\n+\n+ /* Gather some important information about this grid variable */\n+ gi = CCTK_GroupIndexFromVarI(vars[i]);\n+ gtype = CCTK_GroupTypeI(gi);\n+ if (gtype==CCTK_GF)\n+ {\n+ dim = GH->cctk_dim;\n+ bbox = GH->cctk_bbox;\n+ lsh = GH->cctk_lsh;\n+ }\n+ else\n+ {\n+ err = CCTK_GroupDynamicData(GH, gi, &group_data);\n+ if (err)\n+ {\n+ CCTK_VWarn(0, __LINE__, __FILE__, CCTK_THORNSTRING,\n+ \"Error getting group information for group %s. \"\n+ \"Perhaps it is a grid scalar?\", CCTK_GroupName(gi));\n+ retval |= 32;\n+ }\n+ dim = group_data.dim;\n+ bbox = group_data.bbox;\n+ lsh = group_data.lsh;\n+ }\n+ var_ptr = GH->data[vars[i]][0];\n+#ifdef DEBUG\n+ printf(\"dim=%d bbox[0]=%d lsh[1]=%d\\n\", dim, bbox[0], lsh[1]);\n+ printf(\"var_ptr=%p\\n\", var_ptr);\n+#endif\n+\n+ /* Check dimension */\n+ if (dim != 3)\n+ {\n+ CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,\n+ \"Variable dimension of %d not supported. \"\n+\t\t \"Not applying bc.\", dim);\n+ retval |= 16;\n+ }\n+\n+ /* Decide on which faces the bc should be applied */\n+ for (j=0; j<2*dim; ++j)\n+ {\n+ doBC[j] = lsh[j/2] > widths[i]+2 && bbox[j];\n+ }\n+\n+ /* see if we have a physical boundary */\n+ symtable = SymmetryTableHandleForGrid (GH);\n+ if (symtable < 0) CCTK_WARN (0, \"internal error\");\n+ err = Util_TableGetIntArray (symtable, 2 * dim, symbnd, \"symmetry_handle\");\n+ if (err != 2 * dim) CCTK_WARN (0, \"internal error\");\n+ for (j = 0; j < 2 * dim; j++)\n+ {\n+ is_physical[j] = symbnd[j] < 0;\n+ }\n+\n+ /* Only do bc on faces without a symmetry bc */\n+ for (j=0; j<2*dim; ++j)\n+ {\n+ doBC[j] &= is_physical[i];\n+ }\n+\n+ /* Apply the boundary condition */\n+ if( !( retval & ( 1 | 16 ) ) ) /* unless particularly bad errors */\n+ CCTK_FNAME(Linear_extrap_one_bndry)(doBC, lsh, var_ptr);\n+ }\n+\n+ return -retval;\n+}\n+\n+/********************************************************************\n+ ******************** Internal Routines ************************\n+ ********************************************************************/\n+\n+/********************************************************************\n+ ********************* Local Routines *************************\n+ ********************************************************************/" }
{ "test_patch": "diff --git a/all_tests.txt b/all_tests.txt\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/all_tests.txt\n@@ -0,0 +1,1 @@\n+wavetoyc", "pass_criteria": "all_tests_pass" }
{ "scoring_method": "binary", "resolve_points": 100 }
MSB_einsteintoolkit_Cactus_pr10
multi_swe_bench
Add missing GRHydro_Marquina.F90 in EinsteinEvolve/GRHydro (einsteintoolkit/Cactus#10)
{ "org": "einsteintoolkit", "repo": "Cactus", "pr_number": 10, "issue_title": "Add missing GRHydro_Marquina.F90 in EinsteinEvolve/GRHydro", "issue_body": "This PR adds the missing source file GRHydro_Marquina.F90 to complete the EinsteinEvolve/GRHydro thorn implementation.", "base_commit": "HEAD", "resolved_issues": [ { "number": 10, "title": "Implement the full functionality of GRHydro", "body": "Please implement the full functionality of `GRHydro` by finishing the code in `GRHydro_Marquina.F90`.\n\n## Thorn Information:\n- Name: GRHydro\n- Target file: GRHydro_Marquina.F90\n\n## Interface Definition in interface.ccl:\n\n## Schedule Definition in schedule.ccl:\n\n## Parameters Definition in param.ccl:\n\n## Configuration Definition in configuration.ccl:\n\n## Documentation Context in readme.md and doc/documentation.tex\n\n## Related Code Context in src folder\n\n" } ], "commits": [], "diff_url": "", "patch_url": "", "html_url": "", "created_at": "", "merged_at": "" }
{ "env_type": "docker", "docker_image": "mswebench/einsteintoolkit_m_cactus:pr-10", "working_directory": "/testbed", "needs_build": true }
{ "fix_patch": "diff --git a/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_Marquina.F90 b/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_Marquina.F90\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_Marquina.F90\n@@ -0,0 +1,459 @@\n+ /*@@\n+ @file GRHydro_Marquina.f90\n+ @date Thu Jan 11 11:03:32 2002\n+ @author Pedro Montero, Toni Font \n+ @desc \n+ Routine to obtain the Marquina Fluxes. Note that this is the \n+ MODIFIED Marquina formula as given by Aloy et.al. \n+ (ApJ Supp 122 (1999) p.151) and not the full Marquina flux \n+ of Donat and Marquina.\n+ @enddesc \n+ @@*/\n+\n+#include \"cctk.h\"\n+#include \"cctk_Arguments.h\"\n+#include \"cctk_Parameters.h\"\n+#include \"cctk_Functions.h\"\n+\n+#include \"GRHydro_Macros.h\"\n+#include \"SpaceMask.h\"\n+\n+ /*@@\n+ @routine GRHydro_Marquina.f90 \n+ @date Wed Feb 13 11:03:32 2002\n+ @author Pedro Montero, Toni Font\n+ @desc \n+ Routine to obtain the Marquina Fluxes\n+ @enddesc \n+ @calls \n+ @calledby \n+ @history \n+ Based on routines by Toni Font\n+ @endhistory \n+\n+@@*/\n+\n+\n+subroutine GRHydro_Marquina(CCTK_ARGUMENTS)\n+ \n+ implicit none\n+\n+\n+ DECLARE_CCTK_ARGUMENTS\n+ DECLARE_CCTK_PARAMETERS\n+ DECLARE_CCTK_FUNCTIONS\n+ CCTK_REAL, dimension(5) :: marquinaflux, &\n+ consp,consm_i,fplus,fminus,f_marquina,primp,primm_i\n+ CCTK_REAL :: avg_alp,avg_beta,gxxh,gxyh,gxzh,gyyh,gyzh,gzzh, &\n+ avg_det,uxxh,uxyh,uxzh,uyyh,uyzh,uzzh,&\n+ tmp_w_lorentzp, tmp_w_lorentzm_i, w_lorentzp,w_lorentzm_i, usendh\n+ integer :: m\n+ integer :: i,j,k\n+ integer :: keytemp\n+ \n+ CCTK_INT :: type_bits, trivial\n+\n+ if(evolve_temper.eq.1.and.reconstruct_temper.eq.1) then\n+ keytemp = 1\n+ else\n+ keytemp = 0\n+ endif\n+\n+ if (flux_direction == 1) then\n+ call SpaceMask_GetTypeBits(type_bits, \"Hydro_RiemannProblemX\")\n+ call SpaceMask_GetStateBits(trivial, \"Hydro_RiemannProblemX\", &\n+ &\"trivial\")\n+ else if (flux_direction == 2) then\n+ call SpaceMask_GetTypeBits(type_bits, \"Hydro_RiemannProblemY\")\n+ call SpaceMask_GetStateBits(trivial, \"Hydro_RiemannProblemY\", &\n+ &\"trivial\")\n+ else if (flux_direction == 3) then\n+ call SpaceMask_GetTypeBits(type_bits, \"Hydro_RiemannProblemZ\")\n+ call SpaceMask_GetStateBits(trivial, \"Hydro_RiemannProblemZ\", &\n+ &\"trivial\")\n+ else\n+ !Keep this check in here, it is not checked again later\n+ call CCTK_ERROR(\"Flux direction not x,y,z\")\n+ STOP\n+ end if\n+ \n+ f_marquina = 0.d0\n+ \n+ !$OMP PARALLEL DO PRIVATE(i,j,k,consp,consm_i,primp,primm_i,&\n+ !$OMP marquinaflux,avg_beta,avg_alp,gxxh,gxyh,gxzh,gyyh,gyzh,gzzh,&\n+ !$OMP f_marquina,uxxh,uxyh,uxzh,uyyh,uyzh,uzzh,usendh,&\n+ !$OMP tmp_w_lorentzp, tmp_w_lorentzm_i,w_lorentzp,w_lorentzm_i,&\n+ !$OMP fplus,fminus,m,avg_det)\n+ do k = GRHydro_stencil, cctk_lsh(3) - GRHydro_stencil\n+ do j = GRHydro_stencil, cctk_lsh(2) - GRHydro_stencil\n+ do i = GRHydro_stencil, cctk_lsh(1) - GRHydro_stencil\n+\n+!!$ Set the left (p for plus) and right (m_i for minus, i+1) states\n+\n+ consp(1) = densplus(i,j,k) \n+ consp(2) = sxplus(i,j,k)\n+ consp(3) = syplus(i,j,k)\n+ consp(4) = szplus(i,j,k)\n+ consp(5) = tauplus(i,j,k)\n+ \n+ consm_i(1) = densminus(i+xoffset,j+yoffset,k+zoffset)\n+ consm_i(2) = sxminus(i+xoffset,j+yoffset,k+zoffset)\n+ consm_i(3) = syminus(i+xoffset,j+yoffset,k+zoffset)\n+ consm_i(4) = szminus(i+xoffset,j+yoffset,k+zoffset)\n+ consm_i(5) = tauminus(i+xoffset,j+yoffset,k+zoffset) \n+ \n+ primp(1) = rhoplus(i,j,k) \n+ primp(2) = velxplus(i,j,k)\n+ primp(3) = velyplus(i,j,k) \n+ primp(4) = velzplus(i,j,k)\n+ primp(5) = epsplus(i,j,k)\n+ \n+ primm_i(1) = rhominus(i+xoffset,j+yoffset,k+zoffset)\n+ primm_i(2) = velxminus(i+xoffset,j+yoffset,k+zoffset)\n+ primm_i(3) = velyminus(i+xoffset,j+yoffset,k+zoffset)\n+ primm_i(4) = velzminus(i+xoffset,j+yoffset,k+zoffset)\n+ primm_i(5) = epsminus(i+xoffset,j+yoffset,k+zoffset) \n+\n+ marquinaflux = 0.d0\n+ \n+!!$ Set metric terms at interface\n+ \n+ if (flux_direction == 1) then\n+ avg_beta = 0.5d0 * (betax(i+xoffset,j+yoffset,k+zoffset) + &\n+ betax(i,j,k))\n+ else if (flux_direction == 2) then\n+ avg_beta = 0.5d0 * (betay(i+xoffset,j+yoffset,k+zoffset) + &\n+ betay(i,j,k))\n+ else\n+ avg_beta = 0.5d0 * (betaz(i+xoffset,j+yoffset,k+zoffset) + &\n+ betaz(i,j,k))\n+ end if\n+\n+ avg_alp = 0.5 * (alp(i,j,k) + alp(i+xoffset,j+yoffset,k+zoffset))\n+\n+ gxxh = 0.5d0 * (gxx(i+xoffset,j+yoffset,k+zoffset) + &\n+ gxx(i,j,k))\n+ gxyh = 0.5d0 * (gxy(i+xoffset,j+yoffset,k+zoffset) + &\n+ gxy(i,j,k))\n+ gxzh = 0.5d0 * (gxz(i+xoffset,j+yoffset,k+zoffset) + &\n+ gxz(i,j,k))\n+ gyyh = 0.5d0 * (gyy(i+xoffset,j+yoffset,k+zoffset) + &\n+ gyy(i,j,k))\n+ gyzh = 0.5d0 * (gyz(i+xoffset,j+yoffset,k+zoffset) + &\n+ gyz(i,j,k))\n+ gzzh = 0.5d0 * (gzz(i+xoffset,j+yoffset,k+zoffset) + &\n+ gzz(i,j,k))\n+\n+!!$ routine to calculate the determinant of the metric\n+\n+ avg_det = SPATIAL_DETERMINANT(gxxh,gxyh,gxzh,gyyh,gyzh,gzzh)\n+ \n+!!$ If the Riemann problem is trivial, just calculate the fluxes from the \n+!!$ left state and skip to the next cell\n+\n+ if (SpaceMask_CheckStateBitsF90(space_mask, i, j, k, type_bits, trivial)) then\n+\n+ if (flux_direction == 1) then\n+ call num_x_flux(consp(1),consp(2),consp(3),consp(4),consp(5),&\n+ f_marquina(1),f_marquina(2),f_marquina(3),&\n+ f_marquina(4),f_marquina(5),&\n+ velxplus(i,j,k),pressplus(i,j,k),&\n+ avg_det,avg_alp,avg_beta)\n+ else if (flux_direction == 2) then\n+ call num_x_flux(consp(1),consp(3),consp(4),consp(2),consp(5),&\n+ f_marquina(1),f_marquina(3),f_marquina(4),&\n+ f_marquina(2),f_marquina(5),&\n+ velyplus(i,j,k),pressplus(i,j,k),&\n+ avg_det,avg_alp,avg_beta)\n+ else\n+ call num_x_flux(consp(1),consp(4),consp(2),consp(3),consp(5),&\n+ f_marquina(1),f_marquina(4),f_marquina(2),&\n+ f_marquina(3),f_marquina(5),&\n+ velzplus(i,j,k),pressplus(i,j,k),&\n+ avg_det,avg_alp,avg_beta)\n+ end if\n+ \n+ else !!! The end of this branch is right at the bottom of the routine\n+ \n+ call UpperMetric(uxxh, uxyh, uxzh, uyyh, uyzh, uzzh, &\n+ avg_det,gxxh, gxyh, gxzh, gyyh, gyzh, gzzh)\n+ \n+ if (flux_direction == 1) then\n+ usendh = uxxh\n+ else if (flux_direction == 2) then\n+ usendh = uyyh\n+ else\n+ usendh = uzzh\n+ end if\n+\n+!!$left state\n+\n+ tmp_w_lorentzp = gxxh*primp(2)*primp(2) + &\n+ gyyh*primp(3)*primp(3) + gzzh*primp(4)*primp(4) + &\n+ 2*gxyh*primp(2)*primp(3) + 2*gxzh*primp(2) *primp(4) + &\n+ 2*gyzh*primp(3)*primp(4)\n+ if (tmp_w_lorentzp .ge. 1.d0) then\n+ w_lorentzp = GRHydro_lorentz_overshoot_cutoff\n+ else\n+ w_lorentzp = 1.d0 / sqrt(1.d0 - tmp_w_lorentzp);\n+ endif\n+\n+\n+!!$right state\n+\n+ tmp_w_lorentzm_i = gxxh*primm_i(2)*primm_i(2) + &\n+ gyyh*primm_i(3)*primm_i(3) + gzzh*primm_i(4)*primm_i(4) + &\n+ 2*gxyh*primm_i(2)*primm_i(3) + &\n+ 2*gxzh*primm_i(2) *primm_i(4)+ &\n+ 2*gyzh*primm_i(3)*primm_i(4)\n+ if (tmp_w_lorentzm_i .ge. 1.d0) then\n+ w_lorentzm_i = GRHydro_lorentz_overshoot_cutoff\n+ else\n+ w_lorentzm_i = 1.d0 / sqrt(1.d0 - tmp_w_lorentzm_i);\n+ endif\n+\n+ \n+!!$eigenvalues and right eigenvectors\n+ \n+ if (flux_direction == 1) then\n+\n+ if(evolve_temper.eq.0) then\n+ call eigenproblem_marquina(GRHydro_eos_handle,&\n+ primm_i(1),primm_i(2), & \n+ primm_i(3),primm_i(4),primm_i(5),primp(1), &\n+ primp(2),primp(3),primp(4),primp(5), &\n+ gxxh,gxyh,gxzh,gyyh,gyzh,gzzh, &\n+ usendh,avg_det,avg_alp,avg_beta,consp(1),consp(2),&\n+ consp(3), consp(4), consp(5),consm_i(1),consm_i(2), &\n+ consm_i(3),consm_i(4),consm_i(5),marquinaflux(1), &\n+ marquinaflux(2),marquinaflux(3),marquinaflux(4), &\n+ marquinaflux(5))\n+ else\n+ call eigenproblem_marquina_hot(GRHydro_eos_handle,keytemp,&\n+ primm_i(1),primm_i(2), & \n+ primm_i(3),primm_i(4),primm_i(5),primp(1), &\n+ primp(2),primp(3),primp(4),primp(5), &\n+ tempminus(i+xoffset,j+yoffset,k+zoffset),&\n+ tempplus(i,j,k),&\n+ y_e_minus(i+xoffset,j+yoffset,k+zoffset),y_e_plus(i,j,k),&\n+ gxxh,gxyh,gxzh,gyyh,gyzh,gzzh, &\n+ usendh,avg_det,avg_alp,avg_beta,consp(1),consp(2),&\n+ consp(3), consp(4), consp(5),consm_i(1),consm_i(2), &\n+ consm_i(3),consm_i(4),consm_i(5),marquinaflux(1), &\n+ marquinaflux(2),marquinaflux(3),marquinaflux(4), &\n+ marquinaflux(5))\n+\n+ endif\n+ \n+ else if (flux_direction == 2) then\n+\n+ if(evolve_temper.eq.0) then \n+ call eigenproblem_marquina(GRHydro_eos_handle,&\n+ primm_i(1),primm_i(3), & \n+ primm_i(4),primm_i(2),primm_i(5),primp(1), &\n+ primp(3),primp(4),primp(2),primp(5), &\n+ gyyh,gyzh,gxyh,gzzh,gxzh,gxxh, &\n+ usendh,avg_det,avg_alp,avg_beta,consp(1),consp(3),&\n+ consp(4), consp(2), consp(5),consm_i(1),consm_i(3), &\n+ consm_i(4),consm_i(2),consm_i(5),marquinaflux(1), &\n+ marquinaflux(3),marquinaflux(4),marquinaflux(2), &\n+ marquinaflux(5))\n+ else\n+ call eigenproblem_marquina_hot(GRHydro_eos_handle,keytemp,&\n+ primm_i(1),primm_i(3), & \n+ primm_i(4),primm_i(2),primm_i(5),primp(1), &\n+ primp(3),primp(4),primp(2),primp(5), &\n+ tempminus(i+xoffset,j+yoffset,k+zoffset),&\n+ tempplus(i,j,k),&\n+ y_e_minus(i+xoffset,j+yoffset,k+zoffset),y_e_plus(i,j,k),&\n+ gyyh,gyzh,gxyh,gzzh,gxzh,gxxh, &\n+ usendh,avg_det,avg_alp,avg_beta,consp(1),consp(3),&\n+ consp(4), consp(2), consp(5),consm_i(1),consm_i(3), &\n+ consm_i(4),consm_i(2),consm_i(5),marquinaflux(1), &\n+ marquinaflux(3),marquinaflux(4),marquinaflux(2), &\n+ marquinaflux(5))\n+\n+ endif\n+ \n+ else\n+\n+ if(evolve_temper.eq.0) then\n+ call eigenproblem_marquina(GRHydro_eos_handle,&\n+ primm_i(1),primm_i(4), & \n+ primm_i(2),primm_i(3),primm_i(5),primp(1), &\n+ primp(4),primp(2),primp(3),primp(5), &\n+ gzzh,gxzh,gyzh,gxxh,gxyh,gyyh, &\n+ usendh,avg_det,avg_alp,avg_beta,consp(1),consp(4),&\n+ consp(2), consp(3), consp(5),consm_i(1),consm_i(4), &\n+ consm_i(2),consm_i(3),consm_i(5),marquinaflux(1), &\n+ marquinaflux(4),marquinaflux(2),marquinaflux(3), &\n+ marquinaflux(5))\n+ else\n+ call eigenproblem_marquina_hot(GRHydro_eos_handle,keytemp,&\n+ primm_i(1),primm_i(4), & \n+ primm_i(2),primm_i(3),primm_i(5),primp(1), &\n+ primp(4),primp(2),primp(3),primp(5), &\n+ tempminus(i+xoffset,j+yoffset,k+zoffset),&\n+ tempplus(i,j,k),&\n+ y_e_minus(i+xoffset,j+yoffset,k+zoffset),y_e_plus(i,j,k),&\n+ gzzh,gxzh,gyzh,gxxh,gxyh,gyyh, &\n+ usendh,avg_det,avg_alp,avg_beta,consp(1),consp(4),&\n+ consp(2), consp(3), consp(5),consm_i(1),consm_i(4), &\n+ consm_i(2),consm_i(3),consm_i(5),marquinaflux(1), &\n+ marquinaflux(4),marquinaflux(2),marquinaflux(3), &\n+ marquinaflux(5))\n+ endif\n+ end if\n+ \n+ fplus = 0.d0\n+ fminus = 0.d0\n+ \n+!!$calculate the fluxes\n+ \n+ if (flux_direction == 1) then\n+ \n+ call num_x_flux(consp(1),consp(2),consp(3),consp(4),consp(5), &\n+ fplus(1),fplus(2),fplus(3),fplus(4), &\n+ fplus(5),velxplus(i,j,k),pressplus(i,j,k), &\n+ avg_det,avg_alp,avg_beta)\n+ \n+ call num_x_flux(consm_i(1),consm_i(2),consm_i(3), &\n+ consm_i(4),consm_i(5),fminus(1),fminus(2),fminus(3), &\n+ fminus(4), fminus(5), &\n+ velxminus(i+xoffset,j+yoffset,k+zoffset), &\n+ pressminus(i+xoffset,j+yoffset,k+zoffset), &\n+ avg_det,avg_alp,avg_beta)\n+ \n+ else if (flux_direction == 2) then\n+ \n+ call num_x_flux(consp(1),consp(3),consp(4),consp(2),consp(5), &\n+ fplus(1),fplus(3),fplus(4),fplus(2), &\n+ fplus(5),velyplus(i,j,k),pressplus(i,j,k), &\n+ avg_det,avg_alp,avg_beta)\n+ \n+ call num_x_flux(consm_i(1),consm_i(3),consm_i(4), &\n+ consm_i(2),consm_i(5),fminus(1),fminus(3),fminus(4), &\n+ fminus(2), fminus(5), &\n+ velyminus(i+xoffset,j+yoffset,k+zoffset), &\n+ pressminus(i+xoffset,j+yoffset,k+zoffset), &\n+ avg_det,avg_alp,avg_beta)\n+ \n+ else\n+ \n+ call num_x_flux(consp(1),consp(4),consp(2),consp(3),consp(5), &\n+ fplus(1),fplus(4),fplus(2),fplus(3), &\n+ fplus(5),velzplus(i,j,k),pressplus(i,j,k),avg_det, &\n+ avg_alp,avg_beta)\n+ \n+ call num_x_flux(consm_i(1),consm_i(4),consm_i(2), &\n+ consm_i(3),consm_i(5),fminus(1),fminus(4),fminus(2), &\n+ fminus(3), fminus(5), &\n+ velzminus(i+xoffset,j+yoffset,k+zoffset), &\n+ pressminus(i+xoffset,j+yoffset,k+zoffset), &\n+ avg_det,avg_alp,avg_beta)\n+ \n+ end if\n+ \n+!!$ Marquina flux\n+ \n+ do m = 1,5\n+ \n+ f_marquina(m) = 0.5d0 * (fplus(m) + fminus(m) - marquinaflux(m))\n+ \n+ end do\n+\n+ end if !!! The end of the SpaceMask check for a trivial RP.\n+\n+ densflux(i,j,k) = f_marquina(1)\n+ sxflux(i,j,k) = f_marquina(2)\n+ syflux(i,j,k) = f_marquina(3)\n+ szflux(i,j,k) = f_marquina(4)\n+ tauflux(i,j,k) = f_marquina(5)\n+\n+ enddo\n+ enddo\n+ enddo\n+ !$OMP END PARALLEL DO\n+\n+ if (evolve_tracer .ne. 0) then\n+\n+ !$OMP PARALLEL DO PRIVATE(i,j,k)\n+ do k = GRHydro_stencil, cctk_lsh(3) - GRHydro_stencil\n+ do j = GRHydro_stencil, cctk_lsh(2) - GRHydro_stencil\n+ do i = GRHydro_stencil, cctk_lsh(1) - GRHydro_stencil\n+\n+ if (densflux(i, j, k) > 0.d0) then\n+\n+ cons_tracerflux(i, j, k,:) = &\n+ tracerplus(i, j, k,:) * &\n+ densflux(i, j, k)\n+\n+ else\n+\n+ cons_tracerflux(i, j, k,:) = &\n+ tracerminus(i + xoffset, j + yoffset, k + zoffset,:) * &\n+ densflux(i, j, k)\n+\n+ end if\n+\n+ end do\n+ end do\n+ end do\n+ !$OMP END PARALLEL DO\n+\n+ end if\n+\n+ if (evolve_Y_e .ne. 0) then\n+\n+ !$OMP PARALLEL DO PRIVATE(i,j,k)\n+ do k = GRHydro_stencil, cctk_lsh(3) - GRHydro_stencil\n+ do j = GRHydro_stencil, cctk_lsh(2) - GRHydro_stencil\n+ do i = GRHydro_stencil, cctk_lsh(1) - GRHydro_stencil\n+\n+ if (densflux(i, j, k) > 0.d0) then\n+\n+ Y_e_con_flux(i, j, k) = &\n+ Y_e_plus(i, j, k) * &\n+ densflux(i, j, k)\n+\n+ else\n+\n+ Y_e_con_flux(i, j, k) = &\n+ Y_e_minus(i + xoffset, j + yoffset, k + zoffset) * &\n+ densflux(i, j, k)\n+\n+ end if\n+\n+ end do\n+ end do\n+ end do\n+ !$OMP END PARALLEL DO\n+\n+ end if\n+ \n+ return\n+end subroutine GRHydro_Marquina\n+\n+\n+\n+\n+\n+\n+\n+\n+\n+\n+\n+\n+\n+\n+\n+\n+\n+\n+\n+\n+\n+\n+\n+" }
{ "test_patch": "diff --git a/all_tests.txt b/all_tests.txt\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/all_tests.txt\n@@ -0,0 +1,10 @@\n+GRHydro_test_shock\n+GRHydro_test_shock_mp5\n+GRHydro_test_shock_ppm\n+GRHydro_test_tov_ppm_ML\n+GRHydro_test_tov_ppm_ML_disable_internal_excision\n+GRHydro_test_tov_ppm_no_trp_ML\n+test_one_hybrid\n+tov_carpetevolutionmask\n+tov_carpetevolutionmask2\n+tov_slowsector", "pass_criteria": "all_tests_pass" }
{ "scoring_method": "binary", "resolve_points": 100 }
MSB_einsteintoolkit_Cactus_pr11
multi_swe_bench
Add missing GRHydro_PPM.h in EinsteinEvolve/GRHydro (einsteintoolkit/Cactus#11)
{ "org": "einsteintoolkit", "repo": "Cactus", "pr_number": 11, "issue_title": "Add missing GRHydro_PPM.h in EinsteinEvolve/GRHydro", "issue_body": "This PR adds the missing source file GRHydro_PPM.h to complete the EinsteinEvolve/GRHydro thorn implementation.", "base_commit": "HEAD", "resolved_issues": [ { "number": 11, "title": "Implement the full functionality of GRHydro", "body": "Please implement the full functionality of `GRHydro` by finishing the code in `GRHydro_PPM.h`.\n\n## Thorn Information:\n- Name: GRHydro\n- Target file: GRHydro_PPM.h\n\n## Interface Definition in interface.ccl:\n\n## Schedule Definition in schedule.ccl:\n\n## Parameters Definition in param.ccl:\n\n## Configuration Definition in configuration.ccl:\n\n## Documentation Context in readme.md and doc/documentation.tex\n\n## Related Code Context in src folder\n\n" } ], "commits": [], "diff_url": "", "patch_url": "", "html_url": "", "created_at": "", "merged_at": "" }
{ "env_type": "docker", "docker_image": "mswebench/einsteintoolkit_m_cactus:pr-11", "working_directory": "/testbed", "needs_build": true }
{ "fix_patch": "diff --git a/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_PPM.h b/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_PPM.h\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_PPM.h\n@@ -0,0 +1,56 @@\n+#include <assert.h>\n+#include <math.h>\n+#include <stdio.h>\n+#include <stdlib.h>\n+\n+#if 1\n+#include \"cctk.h\"\n+#include \"cctk_Parameters.h\"\n+#include \"cctk_Arguments.h\"\n+#include \"cctk_Functions.h\"\n+#endif\n+\n+#define MIN(a,b) (((a)<(b))?(a):(b))\n+#define MAX(a,b) (((a)>(b))?(a):(b))\n+\n+static inline void steep(double *x, double *dx, double* dmx, const int i) {\n+ if ( (x[i+1] - x[i]) * (x[i]-x[i-1]) > 0.0 ) {\n+ dmx[i] = copysign(1.0,dx[i]) * MIN(fabs(dx[i]),\n+\t\t\t\t\tMIN(2.0*fabs(x[i]-x[i-1]),\n+\t\t\t\t\t 2.0*fabs(x[i+1]-x[i])));\n+ } else {\n+ dmx[i] = 0.0;\n+ }\n+}\n+\n+static inline double approx_at_cell_interface(double* a, const int i) {\n+ return 7.0/12.0*(a[i]+a[i+1]) - 1.0/12.0*(a[i-1]+a[i+2]);\n+}\n+\n+static inline void monotonize(double* restrict xminus,\n+\t\t\t double* restrict x,\n+\t\t\t double* restrict xplus,\n+\t\t\t const int i) {\n+\n+ if ( !(xplus[i]==x[i] && x[i]==xminus[i]) \n+\t&& ( (xplus[i]-x[i])*(x[i]-xminus[i]) <= 0.0 ) ) \n+ {\n+ xminus[i] = x[i];\n+ xplus[i] = x[i];\n+ } else if( 6.0 * (xplus[i]-xminus[i]) * \n+\t\t(x[i]-0.5*(xplus[i]+xminus[i])) >\n+\t\t(xplus[i]-xminus[i])*(xplus[i]-xminus[i]) )\n+ {\n+ xminus[i] = 3.0*x[i]-2.0*xplus[i]; \n+ } else if( 6.0 * (xplus[i]-xminus[i]) * \n+\t (x[i]-0.5*(xplus[i]+xminus[i])) <\n+\t -(xplus[i]-xminus[i])*(xplus[i]-xminus[i]) ) \n+ {\n+ xplus[i] = 3.0*x[i]-2.0*xminus[i]; \n+ }\n+ \n+ return;\n+}\t \t \n+\n+\n+" }
{ "test_patch": "diff --git a/all_tests.txt b/all_tests.txt\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/all_tests.txt\n@@ -0,0 +1,10 @@\n+GRHydro_test_shock\n+GRHydro_test_shock_mp5\n+GRHydro_test_shock_ppm\n+GRHydro_test_tov_ppm_ML\n+GRHydro_test_tov_ppm_ML_disable_internal_excision\n+GRHydro_test_tov_ppm_no_trp_ML\n+test_one_hybrid\n+tov_carpetevolutionmask\n+tov_carpetevolutionmask2\n+tov_slowsector", "pass_criteria": "all_tests_pass" }
{ "scoring_method": "binary", "resolve_points": 100 }
MSB_einsteintoolkit_Cactus_pr12
multi_swe_bench
Add missing GRHydro_LastMoLPostStep.c in EinsteinEvolve/GRHydro (einsteintoolkit/Cactus#12)
{ "org": "einsteintoolkit", "repo": "Cactus", "pr_number": 12, "issue_title": "Add missing GRHydro_LastMoLPostStep.c in EinsteinEvolve/GRHydro", "issue_body": "This PR adds the missing source file GRHydro_LastMoLPostStep.c to complete the EinsteinEvolve/GRHydro thorn implementation.", "base_commit": "HEAD", "resolved_issues": [ { "number": 12, "title": "Implement the full functionality of GRHydro", "body": "Please implement the full functionality of `GRHydro` by finishing the code in `GRHydro_LastMoLPostStep.c`.\n\n## Thorn Information:\n- Name: GRHydro\n- Target file: GRHydro_LastMoLPostStep.c\n\n## Interface Definition in interface.ccl:\n\n## Schedule Definition in schedule.ccl:\n\n## Parameters Definition in param.ccl:\n\n## Configuration Definition in configuration.ccl:\n\n## Documentation Context in readme.md and doc/documentation.tex\n\n## Related Code Context in src folder\n\n" } ], "commits": [], "diff_url": "", "patch_url": "", "html_url": "", "created_at": "", "merged_at": "" }
{ "env_type": "docker", "docker_image": "mswebench/einsteintoolkit_m_cactus:pr-12", "working_directory": "/testbed", "needs_build": true }
{ "fix_patch": "diff --git a/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_LastMoLPostStep.c b/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_LastMoLPostStep.c\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_LastMoLPostStep.c\n@@ -0,0 +1,39 @@\n+// GRHydro_LastMoLPostStep.c\n+//\n+// Compute is this is the last MoL PostStep call. Code taken from Christian\n+// Reisswig's rejected MoL changes.\n+//\n+// Roland Haas\n+// Sun Jun 3 17:35:53 PDT 2012\n+\n+#include <stdio.h>\n+#include <string.h>\n+#include <assert.h>\n+\n+#include \"cctk.h\"\n+#include \"cctk_Arguments.h\"\n+#include \"cctk_Parameters.h\"\n+\n+void GRHydro_SetLastMoLPostStep(CCTK_ARGUMENTS)\n+{\n+ DECLARE_CCTK_ARGUMENTS;\n+\n+ const CCTK_INT *MoL_Intermediate_Step = \n+ CCTK_VarDataPtr(cctkGH,0,\"MoL::MoL_Intermediate_Step\");\n+ if(NULL == MoL_Intermediate_Step)\n+ {\n+ CCTK_WARN(CCTK_WARN_ABORT,\n+ \"Could not get data pointer for MoL::MoL_Intermediate_Step\");\n+ }\n+\n+ // If counter becomes zero, the only thing left to do is to call PostStep!\n+ // NOTE: MoL's counter is uninitialised during initial data setup!\n+ *InLastMoLPostStep = cctk_iteration == 0 || *MoL_Intermediate_Step == 0;\n+}\n+\n+void GRHydro_ClearLastMoLPostStep(CCTK_ARGUMENTS)\n+{\n+ DECLARE_CCTK_ARGUMENTS;\n+\n+ *InLastMoLPostStep = 0;\n+}" }
{ "test_patch": "diff --git a/all_tests.txt b/all_tests.txt\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/all_tests.txt\n@@ -0,0 +1,10 @@\n+GRHydro_test_shock\n+GRHydro_test_shock_mp5\n+GRHydro_test_shock_ppm\n+GRHydro_test_tov_ppm_ML\n+GRHydro_test_tov_ppm_ML_disable_internal_excision\n+GRHydro_test_tov_ppm_no_trp_ML\n+test_one_hybrid\n+tov_carpetevolutionmask\n+tov_carpetevolutionmask2\n+tov_slowsector", "pass_criteria": "all_tests_pass" }
{ "scoring_method": "binary", "resolve_points": 100 }
MSB_einsteintoolkit_Cactus_pr13
multi_swe_bench
Add missing GRHydro_FluxSplit.F90 in EinsteinEvolve/GRHydro (einsteintoolkit/Cactus#13)
{ "org": "einsteintoolkit", "repo": "Cactus", "pr_number": 13, "issue_title": "Add missing GRHydro_FluxSplit.F90 in EinsteinEvolve/GRHydro", "issue_body": "This PR adds the missing source file GRHydro_FluxSplit.F90 to complete the EinsteinEvolve/GRHydro thorn implementation.", "base_commit": "HEAD", "resolved_issues": [ { "number": 13, "title": "Implement the full functionality of GRHydro", "body": "Please implement the full functionality of `GRHydro` by finishing the code in `GRHydro_FluxSplit.F90`.\n\n## Thorn Information:\n- Name: GRHydro\n- Target file: GRHydro_FluxSplit.F90\n\n## Interface Definition in interface.ccl:\n\n## Schedule Definition in schedule.ccl:\n\n## Parameters Definition in param.ccl:\n\n## Configuration Definition in configuration.ccl:\n\n## Documentation Context in readme.md and doc/documentation.tex\n\n## Related Code Context in src folder\n\n" } ], "commits": [], "diff_url": "", "patch_url": "", "html_url": "", "created_at": "", "merged_at": "" }
{ "env_type": "docker", "docker_image": "mswebench/einsteintoolkit_m_cactus:pr-13", "working_directory": "/testbed", "needs_build": true }
{ "fix_patch": "diff --git a/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_FluxSplit.F90 b/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_FluxSplit.F90\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_FluxSplit.F90\n@@ -0,0 +1,869 @@\n+ /*@@\n+ @file GRHydro_FluxSplit.F90\n+ @date Wed Mar 3 22:16:00 2004\n+ @author Ian Hawke\n+ @desc \n+ Flux split reconstruction using WENO5.\n+ @enddesc \n+ @@*/\n+\n+#include \"cctk.h\"\n+#include \"cctk_Arguments.h\"\n+#include \"cctk_Parameters.h\"\n+#include \"cctk_Functions.h\"\n+#include \"GRHydro_Macros.h\"\n+\n+ /*@@\n+ @routine GRHydro_FSAlpha\n+ @date Sun Jan 9 12:25:43 2005\n+ @author Ian Hawke\n+ @desc \n+ Compute the maximum characteristic speed over all space\n+ @enddesc \n+ @calls \n+ @calledby \n+ @history \n+ \n+ @endhistory \n+\n+@@*/\n+\n+\n+subroutine GRHydro_FSAlpha(CCTK_ARGUMENTS)\n+\n+ use GRHydro_Eigenproblem\n+\n+ implicit none\n+ \n+ DECLARE_CCTK_ARGUMENTS\n+ DECLARE_CCTK_PARAMETERS\n+ DECLARE_CCTK_FUNCTIONS\n+\n+ integer :: nx, ny, nz, i, j, k, ierr, max_handle\n+ CCTK_REAL :: uxx, uxy, uxz, uyy, uyz, uzz, sdet, beta\n+ CCTK_REAL, dimension(5) :: lambda\n+ CCTK_REAL :: alpha1_local, alpha2_local, alpha3_local, alpha4_local, &\n+ alpha5_local\n+\n+ nx = cctk_lsh(1)\n+ ny = cctk_lsh(2)\n+ nz = cctk_lsh(3)\n+\n+ fs_alpha1 = 0.d0\n+ fs_alpha2 = 0.d0\n+ fs_alpha3 = 0.d0\n+ fs_alpha4 = 0.d0\n+ fs_alpha5 = 0.d0\n+\n+ alpha1_local = 0.d0\n+ alpha2_local = 0.d0\n+ alpha3_local = 0.d0\n+ alpha4_local = 0.d0\n+ alpha5_local = 0.d0\n+\n+ if (flux_direction == 1) then\n+\n+ do k = 1, nz\n+ do j = 1, ny\n+ do i = 1, nx\n+\n+ sdet = sdetg(i,j,k)\n+ call UpperMetric(uxx,uxy,uxz,uyy,uyz,uzz,sdet*sdet,&\n+ gxx(i,j,k),gxy(i,j,k),gxz(i,j,k),gyy(i,j,k),&\n+ gyz(i,j,k),gzz(i,j,k)) \n+\n+ beta = betax(i,j,k)\n+ \n+ call eigenvalues(GRHydro_eos_handle, &\n+ rho (i,j,k), &\n+ vel (i,j,k,1), &\n+ vel (i,j,k,2), &\n+ vel (i,j,k,3), &\n+ eps (i,j,k), &\n+ w_lorentz(i,j,k), &\n+ lambda , &\n+ gxx (i,j,k), &\n+ gxy (i,j,k), &\n+ gxz (i,j,k), &\n+ gyy (i,j,k), &\n+ gyz (i,j,k), &\n+ gzz (i,j,k), &\n+ uxx , &\n+ alp (i,j,k), &\n+ beta ) \n+\n+ alpha1_local = max(abs(lambda(1)), alpha1_local)\n+ alpha2_local = max(abs(lambda(2)), alpha2_local)\n+ alpha3_local = max(abs(lambda(3)), alpha3_local)\n+ alpha4_local = max(abs(lambda(4)), alpha4_local)\n+ alpha5_local = max(abs(lambda(5)), alpha5_local)\n+\n+ end do\n+ end do\n+ end do\n+\n+ else if (flux_direction == 2) then\n+\n+ do k = 1, nz\n+ do j = 1, ny\n+ do i = 1, nx\n+\n+ sdet = sdetg(i,j,k)\n+ call UpperMetric(uxx,uxy,uxz,uyy,uyz,uzz,sdet*sdet,&\n+ gxx(i,j,k),gxy(i,j,k),gxz(i,j,k),gyy(i,j,k),&\n+ gyz(i,j,k),gzz(i,j,k)) \n+\n+ beta = betay(i,j,k)\n+ \n+ call eigenvalues(GRHydro_eos_handle, &\n+ rho (i,j,k), &\n+ vel (i,j,k,1), &\n+ vel (i,j,k,2), &\n+ vel (i,j,k,3), &\n+ eps (i,j,k), &\n+ w_lorentz(i,j,k), &\n+ lambda , &\n+ gyy (i,j,k), &\n+ gyz (i,j,k), &\n+ gxy (i,j,k), &\n+ gzz (i,j,k), &\n+ gxz (i,j,k), &\n+ gxx (i,j,k), &\n+ uyy , &\n+ alp (i,j,k), &\n+ beta ) \n+\n+ alpha1_local = max(abs(lambda(1)), alpha1_local)\n+ alpha2_local = max(abs(lambda(2)), alpha2_local)\n+ alpha3_local = max(abs(lambda(3)), alpha3_local)\n+ alpha4_local = max(abs(lambda(4)), alpha4_local)\n+ alpha5_local = max(abs(lambda(5)), alpha5_local)\n+\n+ end do\n+ end do\n+ end do\n+\n+ else if (flux_direction == 3) then\n+\n+ do k = 1, nz\n+ do j = 1, ny\n+ do i = 1, nx\n+\n+ sdet = sdetg(i,j,k)\n+ call UpperMetric(uxx,uxy,uxz,uyy,uyz,uzz,sdet*sdet,&\n+ gxx(i,j,k),gxy(i,j,k),gxz(i,j,k),gyy(i,j,k),&\n+ gyz(i,j,k),gzz(i,j,k)) \n+\n+ beta = betaz(i,j,k)\n+ \n+ call eigenvalues(GRHydro_eos_handle, &\n+ rho (i,j,k), &\n+ vel (i,j,k,1), &\n+ vel (i,j,k,2), &\n+ vel (i,j,k,3), &\n+ eps (i,j,k), &\n+ w_lorentz(i,j,k), &\n+ lambda , &\n+ gzz (i,j,k), &\n+ gxz (i,j,k), &\n+ gyz (i,j,k), &\n+ gxx (i,j,k), &\n+ gxy (i,j,k), &\n+ gyy (i,j,k), &\n+ uzz , &\n+ alp (i,j,k), &\n+ beta ) \n+\n+ alpha1_local = max(abs(lambda(1)), alpha1_local)\n+ alpha2_local = max(abs(lambda(2)), alpha2_local)\n+ alpha3_local = max(abs(lambda(3)), alpha3_local)\n+ alpha4_local = max(abs(lambda(4)), alpha4_local)\n+ alpha5_local = max(abs(lambda(5)), alpha5_local)\n+\n+ end do\n+ end do\n+ end do\n+\n+ else\n+\n+ call CCTK_ERROR(\"Flux direction not x,y,z\")\n+ STOP\n+\n+ end if\n+\n+!!$ write(*,*) 'fs_alpha: local',alpha1_local,alpha2_local,alpha3_local,alpha4_local,alpha5_local\n+ \n+ call CCTK_ReductionHandle(max_handle, \"maximum\")\n+\n+ call CCTK_ReduceLocScalar ( ierr, cctkGH, -1, max_handle, &\n+ alpha1_local, fs_alpha1, CCTK_VARIABLE_REAL )\n+ if ( ierr .ne. 0 ) then\n+ call CCTK_ERROR(\"Reduction of alpha1 failed\")\n+ STOP\n+ end if\n+ call CCTK_ReduceLocScalar ( ierr, cctkGH, -1, max_handle, &\n+ alpha2_local, fs_alpha2, CCTK_VARIABLE_REAL )\n+ if ( ierr .ne. 0 ) then\n+ call CCTK_ERROR(\"Reduction of alpha2 failed\")\n+ STOP\n+ end if\n+ call CCTK_ReduceLocScalar ( ierr, cctkGH, -1, max_handle, &\n+ alpha3_local, fs_alpha3, CCTK_VARIABLE_REAL )\n+ if ( ierr .ne. 0 ) then\n+ call CCTK_ERROR(\"Reduction of alpha3 failed\")\n+ STOP\n+ end if\n+ call CCTK_ReduceLocScalar ( ierr, cctkGH, -1, max_handle, &\n+ alpha4_local, fs_alpha4, CCTK_VARIABLE_REAL )\n+ if ( ierr .ne. 0 ) then\n+ call CCTK_ERROR(\"Reduction of alpha4 failed\")\n+ STOP\n+ end if\n+ call CCTK_ReduceLocScalar ( ierr, cctkGH, -1, max_handle, &\n+ alpha5_local, fs_alpha5, CCTK_VARIABLE_REAL )\n+ if ( ierr .ne. 0 ) then\n+ call CCTK_ERROR(\"Reduction of alpha5 failed\")\n+ STOP\n+ end if\n+\n+!!$ write(*,*) 'fs_alpha: global',fs_alpha1,fs_alpha2,fs_alpha3,fs_alpha4,fs_alpha5\n+\n+!!$ fs_alpha1 = max(abs(fs_alpha1), &\n+!!$ abs(fs_alpha2), &\n+!!$ abs(fs_alpha3), &\n+!!$ abs(fs_alpha4), &\n+!!$ abs(fs_alpha5) )\n+!!$\n+!!$ fs_alpha2 = max(abs(fs_alpha1), &\n+!!$ abs(fs_alpha2), &\n+!!$ abs(fs_alpha3), &\n+!!$ abs(fs_alpha4), &\n+!!$ abs(fs_alpha5) )\n+!!$\n+!!$ fs_alpha3 = max(abs(fs_alpha1), &\n+!!$ abs(fs_alpha2), &\n+!!$ abs(fs_alpha3), &\n+!!$ abs(fs_alpha4), &\n+!!$ abs(fs_alpha5) )\n+!!$\n+!!$ fs_alpha4 = max(abs(fs_alpha1), &\n+!!$ abs(fs_alpha2), &\n+!!$ abs(fs_alpha3), &\n+!!$ abs(fs_alpha4), &\n+!!$ abs(fs_alpha5) )\n+!!$\n+!!$ fs_alpha5 = max(abs(fs_alpha1), &\n+!!$ abs(fs_alpha2), &\n+!!$ abs(fs_alpha3), &\n+!!$ abs(fs_alpha4), &\n+!!$ abs(fs_alpha5) )\n+\n+!!$ write(*,*) 'fs_alpha: final',fs_alpha1,fs_alpha2,fs_alpha3,fs_alpha4,fs_alpha5\n+ \n+end subroutine GRHydro_FSAlpha\n+\n+ /*@@\n+ @routine GRHydro_SplitFlux\n+ @date Wed Mar 3 22:17:14 2004\n+ @author Ian Hawke\n+ @desc \n+ Wrapper routine to split the flux. Synchronization is \n+ unfortunately required afterwards.\n+ @enddesc \n+ @calls \n+ @calledby \n+ @history \n+ \n+ @endhistory \n+\n+@@*/\n+\n+\n+subroutine GRHydro_SplitFlux(CCTK_ARGUMENTS)\n+\n+ implicit none\n+ \n+ DECLARE_CCTK_ARGUMENTS\n+ DECLARE_CCTK_PARAMETERS\n+ DECLARE_CCTK_FUNCTIONS\n+\n+ CCTK_INT, parameter :: izero = 0\n+ integer, parameter :: ik = kind(izero)\n+\n+ integer :: nx, ny, nz, i, j, k\n+\n+ CCTK_REAL, dimension(:), allocatable :: upper, det, dummy\n+ CCTK_REAL :: uxx, uxy, uxz, uyy, uyz, uzz\n+\n+ nx = cctk_lsh(1)\n+ ny = cctk_lsh(2)\n+ nz = cctk_lsh(3)\n+\n+ if (flux_direction == 1) then\n+ allocate(upper(nx), det(nx), dummy(nx))\n+ do k = GRHydro_stencil, cctk_lsh(3) - GRHydro_stencil + 2\n+ do j = GRHydro_stencil, cctk_lsh(2) - GRHydro_stencil + 2\n+\n+ dummy = betax(:,j,k)\n+\n+ do i = 1, cctk_lsh(1)\n+ det(i) = sdetg(i,j,k)*sdetg(i,j,k)\n+ call UpperMetric(uxx,uxy,uxz,uyy,uyz,uzz,det(i),&\n+ gxx(i,j,k),gxy(i,j,k),gxz(i,j,k),gyy(i,j,k),&\n+ gyz(i,j,k),gzz(i,j,k)) \n+ upper(i) = uxx\n+ end do\n+\n+ call GRHydro_SplitFlux_1D(GRHydro_eos_handle, int(nx,ik),&\n+ fs_alpha1, fs_alpha2, fs_alpha3, fs_alpha4, fs_alpha5, &\n+ gxx(:,j,k),gxy(:,j,k),gxz(:,j,k),&\n+ gyy(:,j,k),gyz(:,j,k),gzz(:,j,k),&\n+ upper, det,&\n+ alp(:,j,k),dummy,&\n+ rho(:,j,k),vel(:,j,k,1),vel(:,j,k,2),vel(:,j,k,3),press(:,j,k),&\n+ w_lorentz(:,j,k),eps(:,j,k),&\n+ dens(:,j,k),scon(:,j,k,1),scon(:,j,k,2),scon(:,j,k,3),tau(:,j,k),&\n+ densfplus(:,j,k), sxfplus(:,j,k), syfplus(:,j,k), &\n+ szfplus(:,j,k), taufplus(:,j,k), &\n+ densfminus(:,j,k), sxfminus(:,j,k), syfminus(:,j,k), &\n+ szfminus(:,j,k), taufminus(:,j,k), &\n+ densflux(:,j,k), sxflux(:,j,k), syflux(:,j,k), &\n+ szflux(:,j,k), tauflux(:,j,k)) \n+ end do\n+ end do\n+ deallocate(upper, det, dummy)\n+ else if (flux_direction == 2) then\n+ allocate(upper(ny), det(ny), dummy(ny))\n+ do k = GRHydro_stencil, cctk_lsh(3) - GRHydro_stencil + 2\n+ do i = GRHydro_stencil, cctk_lsh(1) - GRHydro_stencil + 2\n+\n+ dummy = betay(i,:,k)\n+\n+ do j = 1, cctk_lsh(2)\n+ det(j) = sdetg(i,j,k)**2\n+ call UpperMetric(uxx,uxy,uxz,uyy,uyz,uzz,det(j),&\n+ gxx(i,j,k),gxy(i,j,k),gxz(i,j,k),gyy(i,j,k),&\n+ gyz(i,j,k),gzz(i,j,k)) \n+ upper(j) = uyy\n+ end do\n+\n+ call GRHydro_SplitFlux_1D(GRHydro_eos_handle, int(ny,ik),&\n+ fs_alpha1, fs_alpha2, fs_alpha3, fs_alpha4, fs_alpha5, &\n+ gyy(i,:,k),gyz(i,:,k),gxy(i,:,k),&\n+ gzz(i,:,k),gxz(i,:,k),gxx(i,:,k),&\n+ upper, det,&\n+ alp(i,:,k),dummy,&\n+ rho(i,:,k),vel(i,:,k,2),vel(i,:,k,3),vel(i,:,k,1),press(i,:,k),&\n+ w_lorentz(i,:,k),eps(i,:,k),&\n+ dens(i,:,k),scon(i,:,k,2),scon(i,:,k,3),scon(i,:,k,1),tau(i,:,k),&\n+ densfplus(i,:,k), syfplus(i,:,k), szfplus(i,:,k), &\n+ sxfplus(i,:,k), taufplus(i,:,k), &\n+ densfminus(i,:,k), syfminus(i,:,k), szfminus(i,:,k), &\n+ sxfminus(i,:,k), taufminus(i,:,k), &\n+ densflux(i,:,k), syflux(i,:,k), szflux(i,:,k), &\n+ sxflux(i,:,k), tauflux(i,:,k))\n+ end do\n+ end do\n+ deallocate(upper, det, dummy)\n+ else if (flux_direction == 3) then\n+ allocate(upper(nz), det(nz), dummy(nz))\n+ do j = GRHydro_stencil, cctk_lsh(2) - GRHydro_stencil + 2\n+ do i = GRHydro_stencil, cctk_lsh(1) - GRHydro_stencil + 2\n+\n+ dummy = betaz(i,j,:)\n+ \n+ do k = 1, cctk_lsh(3)\n+ det(k) = sdetg(i,j,k)*sdetg(i,j,k)\n+ call UpperMetric(uxx,uxy,uxz,uyy,uyz,uzz,det(k),&\n+ gxx(i,j,k),gxy(i,j,k),gxz(i,j,k),gyy(i,j,k),&\n+ gyz(i,j,k),gzz(i,j,k)) \n+ upper(k) = uzz\n+ end do\n+\n+ call GRHydro_SplitFlux_1D(GRHydro_eos_handle, int(nz,ik),&\n+ fs_alpha1, fs_alpha2, fs_alpha3, fs_alpha4, fs_alpha5, &\n+ gzz(i,j,:),gxz(i,j,:),gyz(i,j,:),&\n+ gxx(i,j,:),gxy(i,j,:),gyy(i,j,:),&\n+ upper, det,&\n+ alp(i,j,:),dummy,&\n+ rho(i,j,:),vel(i,j,:,3),vel(i,j,:,1),vel(i,j,:,2),press(i,j,:),&\n+ w_lorentz(i,j,:),eps(i,j,:),&\n+ dens(i,j,:),scon(i,j,:,3),scon(i,j,:,1),scon(i,j,:,2),tau(i,j,:),&\n+ densfplus(i,j,:), szfplus(i,j,:), sxfplus(i,j,:), &\n+ syfplus(i,j,:), taufplus(i,j,:), &\n+ densfminus(i,j,:), szfminus(i,j,:), sxfminus(i,j,:), &\n+ syfminus(i,j,:), taufminus(i,j,:), &\n+ densflux(i,j,:), szflux(i,j,:), sxflux(i,j,:), &\n+ syflux(i,j,:), tauflux(i,j,:))\n+ end do\n+ end do\n+ deallocate(upper, det, dummy)\n+ else\n+ call CCTK_ERROR(\"Flux direction not x,y,z\")\n+ STOP\n+ end if\n+\n+ return\n+\n+end subroutine GRHydro_SplitFlux\n+\n+ /*@@\n+ @routine GRHydro_SplitFlux_1D\n+ @date Wed Mar 3 22:55:36 2004\n+ @author Ian Hawke\n+ @desc \n+ Actually performs the flux splitting. \n+ We really should be doing it on a characteristic basis.\n+\n+ Note the direction rotations on the calling routine.\n+ @enddesc \n+ @calls \n+ @calledby \n+ @history \n+ \n+ @endhistory \n+\n+@@*/\n+\n+subroutine GRHydro_SplitFlux_1D(handle, nx, &\n+ alpha1, alpha2, alpha3, alpha4, alpha5, &\n+ gxx, gxy, gxz, gyy, gyz, gzz, u, det, alp, beta, &\n+ rho, velx1, vely1, velz1, press, w_lorentz, eps, &\n+ dens, sx, sy, sz, tau, &\n+ densfplus, sxfplus, syfplus, szfplus, taufplus, &\n+ densfminus, sxfminus, syfminus, szfminus, taufminus, &\n+ densflux, sxflux, syflux, szflux, tauflux)\n+\n+ use GRHydro_Eigenproblem\n+\n+ implicit none\n+\n+ DECLARE_CCTK_PARAMETERS\n+ DECLARE_CCTK_FUNCTIONS\n+\n+ CCTK_INT, parameter :: izero = 0\n+ integer, parameter :: ik = kind(izero)\n+\n+ CCTK_REAL, parameter :: half = 0.5d0\n+\n+ CCTK_INT :: i, nx, handle, ll\n+ CCTK_REAL, dimension(nx) :: gxx, gxy, gxz, gyy, gyz, gzz, &\n+ u, det, alp, beta, &\n+ rho, velx1, vely1, velz1, press, w_lorentz, eps, &\n+ dens, sx, sy, sz, tau, &\n+ densfplus, sxfplus, syfplus, szfplus, taufplus, &\n+ densfminus, sxfminus, syfminus, szfminus, taufminus, &\n+ densflux, sxflux, syflux, szflux, tauflux\n+\n+ CCTK_REAL :: alpha1, alpha2, alpha3, alpha4, alpha5\n+\n+ CCTK_REAL, dimension(:), allocatable :: tmp\n+\n+ CCTK_REAL, dimension(:,:), allocatable :: evals\n+ CCTK_REAL, dimension(:,:,:), allocatable :: levecs, revecs\n+\n+ CCTK_REAL, dimension(:), allocatable :: &\n+ char_v1, char_v2, char_v3, char_v4 ,char_v5, &\n+ char_f1_plus, char_f2_plus, char_f3_plus, &\n+ char_f4_plus ,char_f5_plus, &\n+ char_f1_minus, char_f2_minus, char_f3_minus, &\n+ char_f4_minus ,char_f5_minus, &\n+ char_f1, char_f2, char_f3, &\n+ char_f4 ,char_f5\n+\n+ CCTK_REAL, dimension(5) :: lambda, alpha\n+ CCTK_REAL, dimension(5, 5) :: levec, revec\n+\n+ densfplus = 0.d0\n+ sxfplus = 0.d0\n+ syfplus = 0.d0\n+ szfplus = 0.d0\n+ taufplus = 0.d0\n+ densfminus = 0.d0\n+ sxfminus = 0.d0\n+ syfminus = 0.d0\n+ szfminus = 0.d0\n+ taufminus = 0.d0\n+\n+ allocate(evals(nx, 5), levecs(nx,5,5), revecs(nx,5,5))\n+ allocate(tmp(nx))\n+ allocate(char_v1(nx), char_v2(nx), char_v3(nx), char_v4 (nx),char_v5(nx), &\n+ char_f1_plus(nx), char_f2_plus(nx), char_f3_plus(nx), &\n+ char_f4_plus (nx),char_f5_plus(nx), &\n+ char_f1_minus(nx), char_f2_minus(nx), char_f3_minus(nx), &\n+ char_f4_minus (nx),char_f5_minus(nx), &\n+ char_f1(nx), char_f2(nx), char_f3(nx), &\n+ char_f4 (nx),char_f5(nx))\n+\n+ do i = 1, nx-1\n+\n+!!$ Arithmetic mean\n+\n+!!$ Calculate the maximum eigenvalue and put it here\n+\n+ call eigenproblem_leftright(handle, &\n+ half * (rho (i) + rho (i+1)), &\n+ half * (velx1 (i) + velx1 (i+1)), &\n+ half * (vely1 (i) + vely1 (i+1)), &\n+ half * (velz1 (i) + velz1 (i+1)), &\n+ half * (eps (i) + eps (i+1)), &\n+ half * (w_lorentz(i) + w_lorentz(i+1)), &\n+ half * (gxx (i) + gxx (i+1)), &\n+ half * (gxy (i) + gxy (i+1)), &\n+ half * (gxz (i) + gxz (i+1)), &\n+ half * (gyy (i) + gyy (i+1)), &\n+ half * (gyz (i) + gyz (i+1)), &\n+ half * (gzz (i) + gzz (i+1)), &\n+ half * (u (i) + u (i+1)), &\n+ half * (alp (i) + alp (i+1)), &\n+ half * (beta (i) + beta (i+1)), &\n+ lambda,&\n+ levec,&\n+ revec)\n+\n+ evals(i,:) = lambda\n+ levecs(i,:,:) = levec\n+ revecs(i,:,:) = revec\n+ \n+ end do\n+ \n+ do i = 3, nx - 3\n+\n+ alpha(1) = alpha1\n+ alpha(2) = alpha2\n+ alpha(3) = alpha3\n+ alpha(4) = alpha4\n+ alpha(5) = alpha5\n+ \n+ do ll = i - 2, i + 3\n+\n+!!$ Initialize the pointwise fluxes temporarily into the minus\n+\n+ call num_x_flux(dens(ll), sx(ll), sy(ll), sz(ll), tau(ll), &\n+ densfminus(ll), sxfminus(ll), syfminus(ll), szfminus(ll), &\n+ taufminus(ll), &\n+ velx1(ll), press(ll), det(ll), alp(ll), beta(ll))\n+\n+ densfminus(ll) = densfminus(ll) * alp(ll)\n+ sxfminus(ll) = sxfminus(ll) * alp(ll)\n+ syfminus(ll) = syfminus(ll) * alp(ll)\n+ szfminus(ll) = szfminus(ll) * alp(ll)\n+ taufminus(ll) = taufminus(ll) * alp(ll)\n+\n+ char_v1(ll) = levecs(i,1,1) * dens(ll) + &\n+ levecs(i,1,2) * sx(ll) + &\n+ levecs(i,1,3) * sy(ll) + &\n+ levecs(i,1,4) * sz(ll) + &\n+ levecs(i,1,5) * tau(ll)\n+ char_v2(ll) = levecs(i,2,1) * dens(ll) + &\n+ levecs(i,2,2) * sx(ll) + &\n+ levecs(i,2,3) * sy(ll) + &\n+ levecs(i,2,4) * sz(ll) + &\n+ levecs(i,2,5) * tau(ll)\n+ char_v3(ll) = levecs(i,3,1) * dens(ll) + &\n+ levecs(i,3,2) * sx(ll) + &\n+ levecs(i,3,3) * sy(ll) + &\n+ levecs(i,3,4) * sz(ll) + &\n+ levecs(i,3,5) * tau(ll)\n+ char_v4(ll) = levecs(i,4,1) * dens(ll) + &\n+ levecs(i,4,2) * sx(ll) + &\n+ levecs(i,4,3) * sy(ll) + &\n+ levecs(i,4,4) * sz(ll) + &\n+ levecs(i,4,5) * tau(ll)\n+ char_v5(ll) = levecs(i,5,1) * dens(ll) + &\n+ levecs(i,5,2) * sx(ll) + &\n+ levecs(i,5,3) * sy(ll) + &\n+ levecs(i,5,4) * sz(ll) + &\n+ levecs(i,5,5) * tau(ll)\n+ \n+ char_f1(ll) = levecs(i,1,1) * densfminus(ll) + &\n+ levecs(i,1,2) * sxfminus(ll) + &\n+ levecs(i,1,3) * syfminus(ll) + &\n+ levecs(i,1,4) * szfminus(ll) + &\n+ levecs(i,1,5) * taufminus(ll)\n+ char_f2(ll) = levecs(i,2,1) * densfminus(ll) + &\n+ levecs(i,2,2) * sxfminus(ll) + &\n+ levecs(i,2,3) * syfminus(ll) + &\n+ levecs(i,2,4) * szfminus(ll) + &\n+ levecs(i,2,5) * taufminus(ll)\n+ char_f3(ll) = levecs(i,3,1) * densfminus(ll) + &\n+ levecs(i,3,2) * sxfminus(ll) + &\n+ levecs(i,3,3) * syfminus(ll) + &\n+ levecs(i,3,4) * szfminus(ll) + &\n+ levecs(i,3,5) * taufminus(ll)\n+ char_f4(ll) = levecs(i,4,1) * densfminus(ll) + &\n+ levecs(i,4,2) * sxfminus(ll) + &\n+ levecs(i,4,3) * syfminus(ll) + &\n+ levecs(i,4,4) * szfminus(ll) + &\n+ levecs(i,4,5) * taufminus(ll)\n+ char_f5(ll) = levecs(i,5,1) * densfminus(ll) + &\n+ levecs(i,5,2) * sxfminus(ll) + &\n+ levecs(i,5,3) * syfminus(ll) + &\n+ levecs(i,5,4) * szfminus(ll) + &\n+ levecs(i,5,5) * taufminus(ll) \n+\n+!!$ Calculate the split\n+\n+ char_f1_plus(ll) = 0.5d0 * (char_f1(ll) + alpha(1) * char_v1(ll))\n+ char_f1_minus(ll) = 0.5d0 * (char_f1(ll) - alpha(1) * char_v1(ll))\n+ char_f2_plus(ll) = 0.5d0 * (char_f2(ll) + alpha(2) * char_v2(ll))\n+ char_f2_minus(ll) = 0.5d0 * (char_f2(ll) - alpha(2) * char_v2(ll))\n+ char_f3_plus(ll) = 0.5d0 * (char_f3(ll) + alpha(3) * char_v3(ll))\n+ char_f3_minus(ll) = 0.5d0 * (char_f3(ll) - alpha(3) * char_v3(ll))\n+ char_f4_plus(ll) = 0.5d0 * (char_f4(ll) + alpha(4) * char_v4(ll))\n+ char_f4_minus(ll) = 0.5d0 * (char_f4(ll) - alpha(4) * char_v4(ll))\n+ char_f5_plus(ll) = 0.5d0 * (char_f5(ll) + alpha(5) * char_v5(ll))\n+ char_f5_minus(ll) = 0.5d0 * (char_f5(ll) - alpha(5) * char_v5(ll))\n+\n+ end do\n+\n+!!$ Reconstruct the characteristic split fluxes\n+!!$ After reconstruction, combine to get the characteristic flux\n+\n+ call GRHydro_WENO5_Left(5_ik, char_f1_plus(i-2:i+2), tmp(i-2:i+2))\n+ char_f1(i) = tmp(i)\n+ call GRHydro_WENO5_Right(5_ik, char_f1_minus(i-1:i+3), &\n+ tmp(i-1:i+3))\n+ char_f1(i) = char_f1(i) + tmp(i+1)\n+ \n+ call GRHydro_WENO5_Left(5_ik, char_f2_plus(i-2:i+2), tmp(i-2:i+2))\n+ char_f2(i) = tmp(i)\n+ call GRHydro_WENO5_Right(5_ik, char_f2_minus(i-1:i+3), &\n+ tmp(i-1:i+3))\n+ char_f2(i) = char_f2(i) + tmp(i+1)\n+ \n+ call GRHydro_WENO5_Left(5_ik, char_f3_plus(i-2:i+2), tmp(i-2:i+2))\n+ char_f3(i) = tmp(i)\n+ call GRHydro_WENO5_Right(5_ik, char_f3_minus(i-1:i+3), &\n+ tmp(i-1:i+3))\n+ char_f3(i) = char_f3(i) + tmp(i+1)\n+ \n+ call GRHydro_WENO5_Left(5_ik, char_f4_plus(i-2:i+2), tmp(i-2:i+2))\n+ char_f4(i) = tmp(i)\n+ call GRHydro_WENO5_Right(5_ik, char_f4_minus(i-1:i+3), &\n+ tmp(i-1:i+3))\n+ char_f4(i) = char_f4(i) + tmp(i+1)\n+ \n+ call GRHydro_WENO5_Left(5_ik, char_f5_plus(i-2:i+2), tmp(i-2:i+2))\n+ char_f5(i) = tmp(i)\n+ call GRHydro_WENO5_Right(5_ik, char_f5_minus(i-1:i+3), &\n+ tmp(i-1:i+3))\n+ char_f5(i) = char_f5(i) + tmp(i+1)\n+\n+!!$ Compute physical fluxes\n+ \n+ densflux(i) = &\n+ revecs(i,1,1) * char_f1(i) + revecs(i,2,1) * char_f2(i) + &\n+ revecs(i,3,1) * char_f3(i) + revecs(i,4,1) * char_f4(i) + &\n+ revecs(i,5,1) * char_f5(i)\n+ sxflux(i) = &\n+ revecs(i,1,2) * char_f1(i) + revecs(i,2,2) * char_f2(i) + &\n+ revecs(i,3,2) * char_f3(i) + revecs(i,4,2) * char_f4(i) + &\n+ revecs(i,5,2) * char_f5(i)\n+ syflux(i) = &\n+ revecs(i,1,3) * char_f1(i) + revecs(i,2,3) * char_f2(i) + &\n+ revecs(i,3,3) * char_f3(i) + revecs(i,4,3) * char_f4(i) + &\n+ revecs(i,5,3) * char_f5(i)\n+ szflux(i) = &\n+ revecs(i,1,4) * char_f1(i) + revecs(i,2,4) * char_f2(i) + &\n+ revecs(i,3,4) * char_f3(i) + revecs(i,4,4) * char_f4(i) + &\n+ revecs(i,5,4) * char_f5(i)\n+ tauflux(i) = &\n+ revecs(i,1,5) * char_f1(i) + revecs(i,2,5) * char_f2(i) + &\n+ revecs(i,3,5) * char_f3(i) + revecs(i,4,5) * char_f4(i) + &\n+ revecs(i,5,5) * char_f5(i)\n+\n+!!$ if (abs(i-200) < 5) then\n+!!$ write(*,*) i, 'alpha',alpha1,alpha2,alpha3,alpha4,alpha5\n+!!$ write(*,*) i, 'var',dens(i), sx(i), tau(i)\n+!!$ write(*,*) i, 'f',densflux(i),sxflux(i),tauflux(i)\n+!!$ end if\n+ \n+ end do\n+\n+ deallocate(evals, levecs, revecs, tmp)\n+\n+end subroutine GRHydro_SplitFlux_1D\n+\n+ /*@@\n+ @routine GRHydro_WENO5_Left\n+ @date Wed Mar 3 22:57:54 2004\n+ @author Ian Hawke\n+ @desc \n+ Upwind biased WENO5.\n+ @enddesc \n+ @calls \n+ @calledby \n+ @history \n+ \n+ @endhistory \n+\n+@@*/\n+\n+subroutine GRHydro_WENO5_Left(nx, v, vminus)\n+\n+ implicit none\n+\n+ CCTK_INT :: i, nx\n+ CCTK_REAL, dimension(nx) :: v, vminus\n+ CCTK_REAL :: one, two, three, four, five, six, seven, &\n+ ten, eleven, twelve, thirteen, &\n+ ThirteenByTwelve, Quarter\n+ parameter (one = 1)\n+ parameter (two = 2)\n+ parameter (three = 3)\n+ parameter (four = 4)\n+ parameter (five = 5)\n+ parameter (six = 6)\n+ parameter (seven = 7)\n+ parameter (ten = 10)\n+ parameter (eleven = 11)\n+ parameter (twelve = 12)\n+ parameter (thirteen = 13)\n+ parameter (ThirteenByTwelve = thirteen / twelve)\n+ parameter (Quarter = one / four)\n+ CCTK_REAL :: d0, d1, d2\n+ parameter (d0 = three / ten)\n+ parameter (d1 = six / ten)\n+ parameter (d2 = one / ten)\n+ CCTK_REAL :: c00,c01,c02,c10,c11,c12,c20,c21,c22\n+ parameter (c00 = two / six)\n+ parameter (c01 = five / six)\n+ parameter (c02 = -one / six)\n+ parameter (c10 = -one / six)\n+ parameter (c11 = five / six)\n+ parameter (c12 = two / six)\n+ parameter (c20 = two / six)\n+ parameter (c21 = -seven / six)\n+ parameter (c22 = eleven / six)\n+\n+ CCTK_REAL :: beta0, beta1, beta2\n+ CCTK_REAL :: epsilon\n+ CCTK_REAL :: alpha0, alpha1, alpha2, alphasum\n+ CCTK_REAL :: w0, w1, w2\n+ CCTK_REAL :: v0plushalf, v1plushalf, v2plushalf\n+\n+ epsilon = 1.d-6\n+\n+ do i = 3, nx-2\n+\n+ beta0 = ThirteenByTwelve * (v(i ) - two * v(i+1) + v(i+2))**2 + &\n+ Quarter * (three * v(i ) - four * v(i+1) + v(i+2))**2\n+ beta1 = ThirteenByTwelve * (v(i-1) - two * v(i ) + v(i+1))**2 + &\n+ Quarter * ( v(i-1) - v(i+1))**2\n+ beta2 = ThirteenByTwelve * (v(i-2) - two * v(i-1) + v(i ))**2 + &\n+ Quarter * ( v(i-2) - four * v(i-1) + three * v(i ))**2\n+ \n+ alpha0 = d0 / (epsilon + beta0)**2\n+ alpha1 = d1 / (epsilon + beta1)**2\n+ alpha2 = d2 / (epsilon + beta2)**2\n+ \n+ alphasum = alpha0 + alpha1 + alpha2\n+ \n+ w0 = alpha0 / alphasum\n+ w1 = alpha1 / alphasum\n+ w2 = alpha2 / alphasum\n+ \n+ v0plushalf = c00 * v(i ) + c01 * v(i+1) + c02 * v(i+2)\n+ v1plushalf = c10 * v(i-1) + c11 * v(i ) + c12 * v(i+1)\n+ v2plushalf = c20 * v(i-2) + c21 * v(i-1) + c22 * v(i )\n+ \n+ vminus(i) = w0 * v0plushalf + &\n+ w1 * v1plushalf + &\n+ w2 * v2plushalf\n+ \n+ end do\n+ \n+end subroutine GRHydro_WENO5_Left\n+\n+ /*@@\n+ @routine GRHydro_WENO5_Right\n+ @date Wed Mar 3 22:58:10 2004\n+ @author Ian Hawke\n+ @desc \n+ Downwind biased WENO5.\n+ @enddesc \n+ @calls \n+ @calledby \n+ @history \n+ \n+ @endhistory \n+\n+@@*/\n+\n+subroutine GRHydro_WENO5_Right(nx, v, vplus)\n+\n+ implicit none\n+\n+ CCTK_INT :: i, nx\n+ CCTK_REAL, dimension(nx) :: v, vplus\n+ CCTK_REAL :: one, two, three, four, five, six, seven, &\n+ ten, eleven, twelve, thirteen, &\n+ ThirteenByTwelve, Quarter\n+ parameter (one = 1)\n+ parameter (two = 2)\n+ parameter (three = 3)\n+ parameter (four = 4)\n+ parameter (five = 5)\n+ parameter (six = 6)\n+ parameter (seven = 7)\n+ parameter (ten = 10)\n+ parameter (eleven = 11)\n+ parameter (twelve = 12)\n+ parameter (thirteen = 13)\n+ parameter (ThirteenByTwelve = thirteen / twelve)\n+ parameter (Quarter = one / four)\n+ CCTK_REAL :: dtilde0, dtilde1, dtilde2\n+ parameter (dtilde0 = one / ten)\n+ parameter (dtilde1 = six / ten)\n+ parameter (dtilde2 = three / ten)\n+ CCTK_REAL :: ctilde00,ctilde01,ctilde02,ctilde10,ctilde11,&\n+ ctilde12,ctilde20,ctilde21,ctilde22\n+ parameter (ctilde00 = eleven / six)\n+ parameter (ctilde01 = -seven / six)\n+ parameter (ctilde02 = two / six)\n+ parameter (ctilde10 = two / six)\n+ parameter (ctilde11 = five / six)\n+ parameter (ctilde12 = -one / six)\n+ parameter (ctilde20 = -one / six)\n+ parameter (ctilde21 = five / six)\n+ parameter (ctilde22 = two / six)\n+\n+ CCTK_REAL :: betatilde0, betatilde1, betatilde2\n+ CCTK_REAL :: epsilon\n+ CCTK_REAL :: alphatilde0, alphatilde1, alphatilde2, alphatildesum\n+ CCTK_REAL :: wtilde0, wtilde1, wtilde2\n+ CCTK_REAL :: v0minushalf, v1minushalf, v2minushalf\n+\n+ epsilon = 1.d-6\n+\n+ do i = 3, nx-2\n+\n+ betatilde0 = ThirteenByTwelve * (v(i ) - two * v(i+1) + v(i+2))**2 + &\n+ Quarter * (three * v(i ) - four * v(i+1) + v(i+2))**2\n+ betatilde1 = ThirteenByTwelve * (v(i-1) - two * v(i ) + v(i+1))**2 + &\n+ Quarter * ( v(i-1) - v(i+1))**2\n+ betatilde2 = ThirteenByTwelve * (v(i-2) - two * v(i-1) + v(i ))**2 + &\n+ Quarter * ( v(i-2) - four * v(i-1) + three * v(i ))**2\n+ \n+ alphatilde0 = dtilde0 / (epsilon + betatilde0)**2\n+ alphatilde1 = dtilde1 / (epsilon + betatilde1)**2\n+ alphatilde2 = dtilde2 / (epsilon + betatilde2)**2\n+ \n+ alphatildesum = alphatilde0 + alphatilde1 + alphatilde2\n+ \n+ wtilde0 = alphatilde0 / alphatildesum\n+ wtilde1 = alphatilde1 / alphatildesum\n+ wtilde2 = alphatilde2 / alphatildesum\n+ \n+ v0minushalf = ctilde00 * v(i ) + ctilde01 * v(i+1) + ctilde02 * v(i+2)\n+ v1minushalf = ctilde10 * v(i-1) + ctilde11 * v(i ) + ctilde12 * v(i+1)\n+ v2minushalf = ctilde20 * v(i-2) + ctilde21 * v(i-1) + ctilde22 * v(i )\n+ \n+ vplus(i) = wtilde0 * v0minushalf + &\n+ wtilde1 * v1minushalf + &\n+ wtilde2 * v2minushalf\n+ \n+ end do\n+ \n+end subroutine GRHydro_WENO5_Right" }
{ "test_patch": "diff --git a/all_tests.txt b/all_tests.txt\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/all_tests.txt\n@@ -0,0 +1,10 @@\n+GRHydro_test_shock\n+GRHydro_test_shock_mp5\n+GRHydro_test_shock_ppm\n+GRHydro_test_tov_ppm_ML\n+GRHydro_test_tov_ppm_ML_disable_internal_excision\n+GRHydro_test_tov_ppm_no_trp_ML\n+test_one_hybrid\n+tov_carpetevolutionmask\n+tov_carpetevolutionmask2\n+tov_slowsector", "pass_criteria": "all_tests_pass" }
{ "scoring_method": "binary", "resolve_points": 100 }
MSB_einsteintoolkit_Cactus_pr14
multi_swe_bench
Add missing GRHydro_HLLEM.F90 in EinsteinEvolve/GRHydro (einsteintoolkit/Cactus#14)
{ "org": "einsteintoolkit", "repo": "Cactus", "pr_number": 14, "issue_title": "Add missing GRHydro_HLLEM.F90 in EinsteinEvolve/GRHydro", "issue_body": "This PR adds the missing source file GRHydro_HLLEM.F90 to complete the EinsteinEvolve/GRHydro thorn implementation.", "base_commit": "HEAD", "resolved_issues": [ { "number": 14, "title": "Implement the full functionality of GRHydro", "body": "Please implement the full functionality of `GRHydro` by finishing the code in `GRHydro_HLLEM.F90`.\n\n## Thorn Information:\n- Name: GRHydro\n- Target file: GRHydro_HLLEM.F90\n\n## Interface Definition in interface.ccl:\n\n## Schedule Definition in schedule.ccl:\n\n## Parameters Definition in param.ccl:\n\n## Configuration Definition in configuration.ccl:\n\n## Documentation Context in readme.md and doc/documentation.tex\n\n## Related Code Context in src folder\n\n" } ], "commits": [], "diff_url": "", "patch_url": "", "html_url": "", "created_at": "", "merged_at": "" }
{ "env_type": "docker", "docker_image": "mswebench/einsteintoolkit_m_cactus:pr-14", "working_directory": "/testbed", "needs_build": true }
{ "fix_patch": "diff --git a/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_HLLEM.F90 b/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_HLLEM.F90\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_HLLEM.F90\n@@ -0,0 +1,823 @@\n+ /*@@\n+ @file GRHydro_HLLEPolyM.F90\n+ @date Aug 30, 2010\n+ @author Joshua Faber, Scott Noble, Bruno Mundim, Ian Hawke, Pedro Montero, Toni Font\n+ @desc \n+ The HLLE solver. Called from the wrapper function, so works in \n+ all directions.\n+ @enddesc \n+ @@*/\n+ \n+#include \"cctk.h\"\n+#include \"cctk_Parameters.h\"\n+#include \"cctk_Arguments.h\"\n+#include \"cctk_Functions.h\"\n+\n+#include \"GRHydro_Macros.h\"\n+#include \"SpaceMask.h\"\n+\n+ /*@@\n+ @routine GRHydro_HLLEM\n+ @date Aug 30, 2010\n+ @author Joshua Faber, Scott Noble, Bruno Mundim, Ian Hawke, Pedro Montero, Toni Font\n+ @desc \n+ The HLLE solver. Sufficiently simple that its just one big routine.\n+ @enddesc \n+ @calls \n+ @calledby \n+ @history \n+ Altered from Cactus 3 routines originally written by Toni Font.\n+ @endhistory \n+\n+@@*/\n+\n+subroutine GRHydro_HLLEM(CCTK_ARGUMENTS)\n+ USE GRHydro_EigenproblemM\n+ USE GRHydro_Scalars\n+\n+ implicit none\n+\n+ DECLARE_CCTK_ARGUMENTS\n+ DECLARE_CCTK_PARAMETERS\n+ DECLARE_CCTK_FUNCTIONS\n+ \n+ CCTK_INT, parameter :: izero = 0\n+ integer, parameter :: ik = kind(izero)\n+\n+ integer :: i, j, k, m\n+ CCTK_REAL, dimension(8) :: cons_p,cons_m,fplus,fminus,f1,qdiff\n+ CCTK_REAL, dimension(10) :: prim_p, prim_m\n+ CCTK_REAL, dimension(5) :: lamminus,lamplus\n+ CCTK_REAL :: charmin, charmax, charpm,chartop,avg_alp,avg_det, sdet\n+ CCTK_REAL, dimension(3,3) :: gh, uh\n+ CCTK_REAL :: usendh\n+ CCTK_REAL :: rhoenth_p, rhoenth_m\n+ CCTK_REAL, dimension(3) :: avg_beta\n+ CCTK_REAL, dimension(3) :: vtp,vtm,blowp,blowm,Bveclowp,Bveclowm\n+ CCTK_REAL, dimension(3) :: vellowp,vellowm\n+ CCTK_REAL :: ab0p,ab0m,b2p,b2m,bdotvp,bdotvm\n+ CCTK_REAL :: wp,wm,v2p,v2m\n+ CCTK_REAL :: pressstarp,pressstarm\n+\n+ CCTK_REAL :: entropyconsp,entropyconsm,entropyp,entropym,entropyf,entropydiff,entropyfp,entropyfm\n+\n+ CCTK_REAL :: psidcp, psidcm, psidcf, psidcdiff, psidcfp, psidcfm\n+ CCTK_REAL :: charmax_dc, charmin_dc, charpm_dc \n+ \n+ CCTK_INT :: type_bits, trivial\n+ CCTK_REAL :: xtemp\n+\n+ integer :: ix,iy,iz\n+\n+ ! save memory when MP is not used\n+ CCTK_INT :: GRHydro_UseGeneralCoordinates\n+ CCTK_REAL, DIMENSION(cctk_ash1,cctk_ash2,cctk_ash3) :: g11, g12, g13, g22, g23, g33\n+ pointer (pg11,g11), (pg12,g12), (pg13,g13), (pg22,g22), (pg23,g23), (pg33,g33)\n+ CCTK_REAL, DIMENSION(cctk_ash1,cctk_ash2,cctk_ash3) :: beta1, beta2, beta3\n+ pointer (pbeta1,beta1), (pbeta2,beta2), (pbeta3,beta3)\n+\n+ if (GRHydro_UseGeneralCoordinates(cctkGH).ne.0) then\n+ pg11 = loc(gaa)\n+ pg12 = loc(gab)\n+ pg13 = loc(gac)\n+ pg22 = loc(gbb)\n+ pg23 = loc(gbc)\n+ pg33 = loc(gcc)\n+ pbeta1 = loc(betaa)\n+ pbeta2 = loc(betab)\n+ pbeta3 = loc(betac)\n+ else\n+ pg11 = loc(gxx)\n+ pg12 = loc(gxy)\n+ pg13 = loc(gxz)\n+ pg22 = loc(gyy)\n+ pg23 = loc(gyz)\n+ pg33 = loc(gzz)\n+ pbeta1 = loc(betax)\n+ pbeta2 = loc(betay)\n+ pbeta3 = loc(betaz)\n+ end if\n+#define gxx faulty_gxx\n+#define gxy faulty_gxy\n+#define gxz faulty_gxz\n+#define gyy faulty_gyy\n+#define gyz faulty_gyz\n+#define gzz faulty_gzz\n+#define betax faulty_betax\n+#define betay faulty_betay\n+#define betaz faulty_betaz\n+#define vel faulty_vel\n+#define Bvec faulty_Bvec\n+\n+ if (flux_direction == 1) then\n+ call SpaceMask_GetTypeBits(type_bits, \"Hydro_RiemannProblemX\")\n+ call SpaceMask_GetStateBits(trivial, \"Hydro_RiemannProblemX\", &\n+ &\"trivial\")\n+ ix = 1 ; iy = 2 ; iz = 3\n+ else if (flux_direction == 2) then\n+ call SpaceMask_GetTypeBits(type_bits, \"Hydro_RiemannProblemY\")\n+ call SpaceMask_GetStateBits(trivial, \"Hydro_RiemannProblemY\", &\n+ &\"trivial\")\n+ ix = 2 ; iy = 3 ; iz = 1\n+ else if (flux_direction == 3) then\n+ call SpaceMask_GetTypeBits(type_bits, \"Hydro_RiemannProblemZ\")\n+ call SpaceMask_GetStateBits(trivial, \"Hydro_RiemannProblemZ\", &\n+ &\"trivial\")\n+ ix = 3 ; iy = 1 ; iz = 2\n+ else\n+ call CCTK_ERROR(\"Flux direction not x,y,z\")\n+ STOP\n+ end if\n+\n+ ! constraint transport needs to be able to average fluxes in the directions\n+ ! other that flux_direction\n+\n+ !$OMP PARALLEL PRIVATE(k,j,i,f1,lamminus,lamplus,cons_p,cons_m,fplus,fminus,qdiff,psidcf,psidcp,psidcm,prim_p,prim_m,&\n+ !$OMP avg_beta,avg_alp,&\n+ !$OMP gh,avg_det,sdet,uh,&\n+ !$OMP vtp,vtm,vellowp,vellowm,Bveclowp,Bveclowm,&\n+ !$OMP bdotvp,bdotvm,b2p,b2m,v2p,v2m,wp,wm,&\n+ !$OMP blowp,blowm,&\n+ !$OMP rhoenth_p,rhoenth_m,ab0p,ab0m,pressstarp,pressstarm,&\n+ !$OMP usendh,psidcdiff,psidcfp,psidcfm,charmin,charmax,chartop,charpm,&\n+ !$OMP charmin_dc,charmax_dc,charpm_dc,m,xtemp,&\n+ !$OMP entropyconsp,entropyconsm,entropyp,entropym,entropyf,entropydiff,entropyfp,entropyfm)\n+ ! avoid compiler warnings\n+ psidcf = 0d0\n+ psidcp = 0.d0\n+ psidcm = 0d0\n+ psidcfp = 0d0\n+ psidcfm = 0d0\n+\n+ entropyf = 0d0\n+ entropyfp = 0d0\n+ entropyfm = 0d0\n+ entropyconsm = 0d0\n+ entropyconsp = 0d0\n+ !$OMP DO\n+ do k = GRHydro_stencil, cctk_lsh(3) - GRHydro_stencil + transport_constraints*(1-zoffset)\n+ do j = GRHydro_stencil, cctk_lsh(2) - GRHydro_stencil + transport_constraints*(1-yoffset)\n+ do i = GRHydro_stencil, cctk_lsh(1) - GRHydro_stencil + transport_constraints*(1-xoffset)\n+ \n+ f1 = 0.d0\n+ lamminus = 0.d0\n+ lamplus = 0.d0\n+ cons_p = 0.d0\n+ cons_m = 0.d0\n+ fplus = 0.d0\n+ fminus = 0.d0\n+ qdiff = 0.d0\n+\n+!!$ Set the left (p for plus) and right (m_i for minus, i+1) states\n+ \n+ cons_p(1) = densplus(i,j,k) \n+ cons_p(2) = sxplus(i,j,k)\n+ cons_p(3) = syplus(i,j,k)\n+ cons_p(4) = szplus(i,j,k)\n+ cons_p(5) = tauplus(i,j,k)\n+ cons_p(6) = Bconsxplus(i,j,k)\n+ cons_p(7) = Bconsyplus(i,j,k)\n+ cons_p(8) = Bconszplus(i,j,k)\n+ \n+ cons_m(1) = densminus(i+xoffset,j+yoffset,k+zoffset)\n+ cons_m(2) = sxminus(i+xoffset,j+yoffset,k+zoffset)\n+ cons_m(3) = syminus(i+xoffset,j+yoffset,k+zoffset)\n+ cons_m(4) = szminus(i+xoffset,j+yoffset,k+zoffset)\n+ cons_m(5) = tauminus(i+xoffset,j+yoffset,k+zoffset) \n+ cons_m(6) = Bconsxminus(i+xoffset,j+yoffset,k+zoffset) \n+ cons_m(7) = Bconsyminus(i+xoffset,j+yoffset,k+zoffset) \n+ cons_m(8) = Bconszminus(i+xoffset,j+yoffset,k+zoffset) \n+\n+ prim_p(1) = rhoplus(i,j,k) \n+ prim_p(2) = velxplus(i,j,k)\n+ prim_p(3) = velyplus(i,j,k) \n+ prim_p(4) = velzplus(i,j,k)\n+ prim_p(5) = epsplus(i,j,k)\n+ prim_p(6) = pressplus(i,j,k)\n+ prim_p(7) = w_lorentzplus(i,j,k)\n+ prim_p(8) = Bvecxplus(i,j,k)\n+ prim_p(9) = Bvecyplus(i,j,k) \n+ prim_p(10) = Bveczplus(i,j,k)\n+ \n+ prim_m(1) = rhominus(i+xoffset,j+yoffset,k+zoffset)\n+ prim_m(2) = velxminus(i+xoffset,j+yoffset,k+zoffset)\n+ prim_m(3) = velyminus(i+xoffset,j+yoffset,k+zoffset)\n+ prim_m(4) = velzminus(i+xoffset,j+yoffset,k+zoffset)\n+ prim_m(5) = epsminus(i+xoffset,j+yoffset,k+zoffset) \n+ prim_m(6) = pressminus(i+xoffset,j+yoffset,k+zoffset) \n+ prim_m(7) = w_lorentzminus(i+xoffset,j+yoffset,k+zoffset) \n+ prim_m(8) = Bvecxminus(i+xoffset,j+yoffset,k+zoffset) \n+ prim_m(9) = Bvecyminus(i+xoffset,j+yoffset,k+zoffset) \n+ prim_m(10)= Bveczminus(i+xoffset,j+yoffset,k+zoffset) \n+ \n+ if(clean_divergence.ne.0) then\n+ psidcp = psidcplus(i,j,k)\n+ psidcm = psidcminus(i+xoffset,j+yoffset,k+zoffset)\n+ endif\n+\n+ if(evolve_entropy.ne.0) then\n+ entropyp = entropyplus(i,j,k)\n+ entropym = entropyminus(i+xoffset,j+yoffset,k+zoffset)\n+ entropyconsp = entropyconsplus(i,j,k)\n+ entropyconsm = entropyconsminus(i+xoffset,j+yoffset,k+zoffset)\n+ endif\n+\n+!!$ Calculate various metric terms here.\n+!!$ Note also need the average of the lapse at the \n+!!$ left and right points.\n+!!$ \n+!!$ In MHD, we need all three shift components regardless of the flux direction\n+\n+ avg_beta(1) = 0.5d0 * (beta1(i+xoffset,j+yoffset,k+zoffset) + &\n+ beta1(i,j,k))\n+ avg_beta(2) = 0.5d0 * (beta2(i+xoffset,j+yoffset,k+zoffset) + &\n+ beta2(i,j,k))\n+ avg_beta(3) = 0.5d0 * (beta3(i+xoffset,j+yoffset,k+zoffset) + &\n+ beta3(i,j,k))\n+\n+ avg_alp = 0.5 * (alp(i,j,k) + alp(i+xoffset,j+yoffset,k+zoffset))\n+ \n+ gh(1,1) = 0.5d0 * (g11(i+xoffset,j+yoffset,k+zoffset) + g11(i,j,k))\n+ gh(1,2) = 0.5d0 * (g12(i+xoffset,j+yoffset,k+zoffset) + g12(i,j,k))\n+ gh(1,3) = 0.5d0 * (g13(i+xoffset,j+yoffset,k+zoffset) + g13(i,j,k))\n+ gh(2,2) = 0.5d0 * (g22(i+xoffset,j+yoffset,k+zoffset) + g22(i,j,k))\n+ gh(2,3) = 0.5d0 * (g23(i+xoffset,j+yoffset,k+zoffset) + g23(i,j,k))\n+ gh(3,3) = 0.5d0 * (g33(i+xoffset,j+yoffset,k+zoffset) + g33(i,j,k))\n+ gh(2,1) = gh(1,2) ; gh(3,1) = gh(1,3) ; gh(3,2) = gh(2,3)\n+\n+ avg_det = SPATIAL_DETERMINANT(gh(1,1),gh(1,2),gh(1,3),gh(2,2),gh(2,3),gh(3,3))\n+ sdet = sqrt(avg_det)\n+\n+ call UpperMetric(uh(1,1), uh(1,2), uh(1,3), uh(2,2), uh(2,3), uh(3,3), &\n+ avg_det,gh(1,1), gh(1,2), gh(1,3), &\n+ gh(2,2), gh(2,3), gh(3,3))\n+ uh(2,1) = uh(1,2) ; uh(3,1) = uh(1,3) ; uh(3,2) = uh(2,3)\n+ \n+\n+ vtp(1) = prim_p(2)-avg_beta(1)/avg_alp\n+ vtp(2) = prim_p(3)-avg_beta(2)/avg_alp\n+ vtp(3) = prim_p(4)-avg_beta(3)/avg_alp\n+ vtm(1) = prim_m(2)-avg_beta(1)/avg_alp\n+ vtm(2) = prim_m(3)-avg_beta(2)/avg_alp\n+ vtm(3) = prim_m(4)-avg_beta(3)/avg_alp\n+\n+ call calc_vlow_blow(gh(1,1),gh(1,2),gh(1,3),gh(2,2),gh(2,3),gh(3,3), &\n+ prim_p(2),prim_p(3),prim_p(4),prim_p(8),prim_p(9),prim_p(10), &\n+ vellowp(1),vellowp(2),vellowp(3),Bveclowp(1),Bveclowp(2),Bveclowp(3), &\n+ bdotvp,b2p,v2p,wp,blowp(1),blowp(2),blowp(3))\n+ call calc_vlow_blow(gh(1,1),gh(1,2),gh(1,3),gh(2,2),gh(2,3),gh(3,3), &\n+ prim_m(2),prim_m(3),prim_m(4),prim_m(8),prim_m(9),prim_m(10), &\n+ vellowm(1),vellowm(2),vellowm(3),Bveclowm(1),Bveclowm(2),Bveclowm(3), &\n+ bdotvm,b2m,v2m,wm,blowm(1),blowm(2),blowm(3))\n+\n+ rhoenth_p = prim_p(1)*(1.d0+prim_p(5))+prim_p(6)\n+ rhoenth_m = prim_m(1)*(1.d0+prim_m(5))+prim_m(6)\n+ \n+ ab0p = wp*bdotvp\n+ ab0m = wm*bdotvm\n+\n+!!$ p^* = p+b^2/2 in Anton et al.\n+ pressstarp = prim_p(6)+0.5d0*b2p\n+ pressstarm = prim_m(6)+0.5d0*b2m \n+\n+\n+!!$ If the Riemann problem is trivial, just calculate the fluxes from the \n+!!$ left state and skip to the next cell\n+ \n+ if (SpaceMask_CheckStateBitsF90(space_mask, i, j, k, type_bits, trivial)) then\n+ \n+!!$ we now pass in the B-field as conserved and flux, the vtilde's instead of v's,\n+!!$ pressstar instead of P, b_i, alp b^0, w, metric determinant, \n+!!$ alp, and beta in the flux dir\n+\n+ call num_x_fluxM(cons_p(1),cons_p(1+ix),cons_p(1+iy),cons_p(1+iz),&\n+ cons_p(5),cons_p(5+ix),cons_p(5+iy),cons_p(5+iz),&\n+ f1(1),f1(1+ix),f1(1+iy),f1(1+iz),f1(5),f1(5+ix),f1(5+iy),&\n+ f1(5+iz),&\n+ vtp(ix),vtp(iy),vtp(iz),pressstarp,blowp(ix),blowp(iy),&\n+ blowp(iz),ab0p,wp, &\n+ avg_det,avg_alp,avg_beta(flux_direction))\n+ if(clean_divergence.ne.0) then\n+ f1(6)=f1(6) + 1.0d0*sdet*uh(flux_direction,1)*psidcp - cons_p(5+flux_direction)*avg_beta(1)/avg_alp\n+ f1(7)=f1(7) + 1.0d0*sdet*uh(flux_direction,2)*psidcp - cons_p(5+flux_direction)*avg_beta(2)/avg_alp\n+ f1(8)=f1(8) + 1.0d0*sdet*uh(flux_direction,3)*psidcp - cons_p(5+flux_direction)*avg_beta(3)/avg_alp\n+ psidcf = cons_p(5+flux_direction)/sdet-psidcp*avg_beta(flux_direction)/avg_alp\n+ endif\n+ if(evolve_entropy.ne.0) then\n+ entropyf = entropyconsp*vtp(flux_direction)\n+ endif\n+ \n+ else !!! The end of this branch is right at the bottom of the routine\n+ \n+ usendh = uh(flux_direction,flux_direction)\n+ \n+!!$ Calculate the jumps in the conserved variables\n+ \n+ qdiff = cons_m - cons_p\n+\n+ if (clean_divergence.ne.0) then\n+ psidcdiff = psidcm - psidcp\n+ endif\n+ if(evolve_entropy.ne.0) then\n+ entropydiff = entropyconsm - entropyconsp\n+ endif\n+\n+!!$ Eigenvalues and fluxes either side of the cell interface\n+ \n+ if(evolve_temper.ne.1) then\n+ call eigenvaluesM(GRHydro_eos_handle,&\n+ prim_m(1),prim_m(1+ix),prim_m(1+iy),prim_m(1+iz),prim_m(5),prim_m(6),prim_m(7), &\n+ prim_m(7+ix),prim_m(7+iy),prim_m(7+iz),&\n+ lamminus,gh(1,1),gh(1,2),gh(1,3),gh(2,2),gh(2,3),gh(3,3),&\n+ usendh,avg_alp,avg_beta(flux_direction))\n+ call eigenvaluesM(GRHydro_eos_handle,&\n+ prim_p(1),prim_p(1+ix),prim_p(1+iy),prim_p(1+iz),prim_p(5),prim_p(6),prim_p(7), &\n+ prim_p(7+ix),prim_p(7+iy),prim_p(7+iz),&\n+ lamplus,gh(1,1),gh(1,2),gh(1,3),gh(2,2),gh(2,3),gh(3,3),&\n+ usendh,avg_alp,avg_beta(flux_direction))\n+ else\n+ xtemp = temperature(i,j,k)\n+ call eigenvaluesM_hot(GRHydro_eos_handle,&\n+ int(i,ik),int(j,ik),int(k,ik),&\n+ prim_m(1),prim_m(1+ix),prim_m(1+iy),prim_m(1+iz),prim_m(5),prim_m(6),prim_m(7), &\n+ prim_m(7+ix),prim_m(7+iy),prim_m(7+iz),&\n+ xtemp,y_e_minus(i+xoffset,j+yoffset,k+zoffset),&\n+ lamminus,gh(1,1),gh(1,2),gh(1,3),gh(2,2),gh(2,3),gh(3,3),&\n+ usendh,avg_alp,avg_beta(flux_direction))\n+ xtemp = temperature(i,j,k)\n+ call eigenvaluesM_hot(GRHydro_eos_handle,&\n+ int(i,ik),int(j,ik),int(k,ik),&\n+ prim_p(1),prim_p(1+ix),prim_p(1+iy),prim_p(1+iz),prim_p(5),prim_p(6),prim_p(7), &\n+ prim_p(7+ix),prim_p(7+iy),prim_p(7+iz),&\n+ xtemp,y_e_plus(i,j,k),&\n+ lamplus,gh(1,1),gh(1,2),gh(1,3),gh(2,2),gh(2,3),gh(3,3),&\n+ usendh,avg_alp,avg_beta(flux_direction))\n+ endif \n+\n+ call num_x_fluxM(cons_p(1),cons_p(1+ix),cons_p(1+iy),cons_p(1+iz),&\n+ cons_p(5),&\n+ cons_p(5+ix),cons_p(5+iy),cons_p(5+iz),&\n+ fplus(1),fplus(1+ix),fplus(1+iy),fplus(1+iz),fplus(5),&\n+ fplus(5+ix),fplus(5+iy),fplus(5+iz),&\n+ vtp(ix),vtp(iy),vtp(iz),pressstarp,blowp(ix),blowp(iy),&\n+ blowp(iz),ab0p,wp, &\n+ avg_det,avg_alp,avg_beta(flux_direction))\n+ call num_x_fluxM(cons_m(1),cons_m(1+ix),cons_m(1+iy),cons_m(1+iz),&\n+ cons_m(5),&\n+ cons_m(5+ix),cons_m(5+iy),cons_m(5+iz),&\n+ fminus(1),fminus(1+ix),fminus(1+iy),fminus(1+iz),fminus(5),&\n+ fminus(5+ix),fminus(5+iy),fminus(5+iz),&\n+ vtm(ix),vtm(iy),vtm(iz),pressstarm,blowm(ix),blowm(iy),&\n+ blowm(iz),ab0m,wm, &\n+ avg_det,avg_alp,avg_beta(flux_direction))\n+\n+ if(clean_divergence.ne.0) then\n+ fminus(6)=fminus(6) + 1.0d0*sdet*uh(flux_direction,1)*psidcm - cons_m(5+flux_direction)*avg_beta(1)/avg_alp\n+ fminus(7)=fminus(7) + 1.0d0*sdet*uh(flux_direction,2)*psidcm - cons_m(5+flux_direction)*avg_beta(2)/avg_alp\n+ fminus(8)=fminus(8) + 1.0d0*sdet*uh(flux_direction,3)*psidcm - cons_m(5+flux_direction)*avg_beta(3)/avg_alp\n+ fplus(6)=fplus(6) + 1.0d0*sdet*uh(flux_direction,1)*psidcp - cons_p(5+flux_direction)*avg_beta(1)/avg_alp\n+ fplus(7)=fplus(7) + 1.0d0*sdet*uh(flux_direction,2)*psidcp - cons_p(5+flux_direction)*avg_beta(2)/avg_alp\n+ fplus(8)=fplus(8) + 1.0d0*sdet*uh(flux_direction,3)*psidcp - cons_p(5+flux_direction)*avg_beta(3)/avg_alp\n+ psidcfp = cons_p(5+flux_direction)/sdet-avg_beta(flux_direction)*psidcp/avg_alp\n+ psidcfm = cons_m(5+flux_direction)/sdet-avg_beta(flux_direction)*psidcm/avg_alp\n+ endif\n+ if(evolve_entropy.ne.0) then\n+ entropyfp = entropyconsp*vtp(flux_direction)\n+ entropyfm = entropyconsm*vtm(flux_direction)\n+ endif\n+\n+!!$ Find minimum and maximum wavespeeds\n+ \n+ charmin = min(0.d0, lamplus(1), lamplus(2), lamplus(3), &\n+ lamplus(4),lamplus(5), lamminus(1),lamminus(2),lamminus(3),&\n+ lamminus(4),lamminus(5)) \n+ \n+ charmax = max(0.d0, lamplus(1), lamplus(2), lamplus(3), &\n+ lamplus(4),lamplus(5), lamminus(1),lamminus(2),lamminus(3),&\n+ lamminus(4),lamminus(5))\n+\n+ chartop = max(-charmin,charmax)\n+ \n+ charpm = charmax - charmin\n+\n+!!$ Calculate flux by standard formula\n+ \n+ do m = 1,8 \n+ \n+ qdiff(m) = cons_m(m) - cons_p(m)\n+ \n+ if (HLLE) then\n+ f1(m) = (charmax * fplus(m) - charmin * fminus(m) + &\n+ charmax * charmin * qdiff(m)) / charpm\n+ else if (LLF) then\n+ f1(m) = 0.5d0 * (fplus(m) + fminus(m) - chartop * qdiff(m)) \n+ end if \n+ \n+ end do\n+\n+ if(clean_divergence.ne.0) then\n+\n+ psidcdiff = psidcm - psidcp\n+ select case(whichpsidcspeed)\n+ case(0)\n+ if (HLLE) then\n+ psidcf = (charmax * psidcfp - charmin * psidcfm + &\n+ charmax * charmin * psidcdiff) / charpm\n+ else if (LLF) then\n+ psidcf = 0.5d0 * (psidcfp + psidcfm - chartop * psidcdiff)\n+ end if\n+ case(1)\n+ !!$ Wavespeeds for psidc are +/-c, not Fast Magnetosonic?\n+ !!$ psidcf = 0.5d0 * (1.d0 * psidcfp - (-1.d0) * psidcfm + &\n+ !!$ 1.d0 * (-1.d0) * psidcdiff) \n+\n+ !!$ The fastest speed for psidc comes from the condition\n+ !!$ that the normal vector to the characteristic hypersurface\n+ !!$ be spacelike (Eq. 60 of Anton et al.)\n+\n+ charmax_dc = sqrt(usendh) - avg_beta(flux_direction)/avg_alp\n+ charmin_dc = -1.d0*sqrt(usendh) - avg_beta(flux_direction)/avg_alp\n+ charpm_dc = charmax_dc - charmin_dc\n+\n+ psidcf = (charmax_dc * psidcfp - charmin_dc * psidcfm + &\n+ charmax_dc * charmin_dc * psidcdiff) / charpm_dc\n+\n+ if(decouple_normal_Bfield .ne. 0) then ! same expression for HLLE and LLF\n+ !!$ B^i field decouples from the others and has same propagation\n+ !!$ speed as divergence -null direction, \n+ !!$ \\pm sqrt(g^{xx}} - beta^x/alpha\n+ f1(5+flux_direction) = (charmax_dc * fplus(5+flux_direction) &\n+ - charmin_dc * fminus(5+flux_direction) + &\n+ charmax_dc * charmin_dc * qdiff(5+flux_direction)) / charpm_dc\n+ end if\n+ case(2)\n+ charmax = setcharmax\n+ charmin = setcharmin\n+ if (HLLE) then\n+ psidcf = (charmax * psidcfp - charmin * psidcfm + &\n+ charmax * charmin * psidcdiff) / charpm\n+ else if (LLF) then\n+ chartop = max(-charmin,charmax)\n+ psidcf = 0.5d0 * (psidcfp + psidcfm - chartop * psidcdiff)\n+ end if\n+ end select\n+ endif\n+ \n+ if(evolve_entropy.ne.0) then\n+ entropydiff = entropyconsm - entropyconsp\n+ if (HLLE) then\n+ entropyf = (charmax * entropyfp - charmin * entropyfm + &\n+ charmax * charmin * entropydiff) / charpm\n+ else if (LLF) then\n+ entropyf = 0.5d0 * (entropyfp + entropyfm - chartop * entropydiff) \n+ end if \n+ endif\n+ \n+ \n+\n+ end if !!! The end of the SpaceMask check for a trivial RP.\n+ \n+ densflux(i, j, k) = f1(1)\n+ sxflux(i, j, k) = f1(2)\n+ syflux(i, j, k) = f1(3)\n+ szflux(i, j, k) = f1(4)\n+ tauflux(i, j, k) = f1(5)\n+\n+ Bconsxflux(i, j, k) = f1(6)\n+ Bconsyflux(i, j, k) = f1(7)\n+ Bconszflux(i, j, k) = f1(8)\n+\n+ if(clean_divergence.ne.0) then\n+ psidcflux(i,j,k) = psidcf\n+ endif\n+\n+ if(evolve_entropy.ne.0) then\n+ entropyflux(i,j,k) = entropyf\n+ endif\n+\n+ if(evolve_Y_e.ne.0) then\n+ if (densflux(i, j, k) > 0.d0) then\n+ Y_e_con_flux(i, j, k) = &\n+ Y_e_plus(i, j, k) * &\n+ densflux(i, j, k)\n+ else\n+ Y_e_con_flux(i, j, k) = &\n+ Y_e_minus(i + xoffset, j + yoffset, k + zoffset) * &\n+ densflux(i, j, k)\n+ endif\n+ endif\n+\n+ end do\n+ end do\n+ end do\n+ !$OMP END DO\n+ !$OMP END PARALLEL\n+#undef faulty_gxx\n+#undef faulty_gxy\n+#undef faulty_gxz\n+#undef faulty_gyy\n+#undef faulty_gyz\n+#undef faulty_gzz\n+#undef faulty_betax\n+#undef faulty_betay\n+#undef faulty_betaz\n+#undef faulty_vel\n+#undef faulty_Bvec\n+ \n+end subroutine GRHydro_HLLEM\n+\n+ /*@@\n+ @routine GRHydro_HLLE_TracerM\n+ @date Aug 30, 2010\n+ @author Joshua Faber, Scott Noble, Bruno Mundim, Ian Hawke\n+ @desc \n+ HLLE just for the tracer.\n+ @enddesc \n+ @calls \n+ @calledby \n+ @history \n+ \n+ @endhistory \n+\n+@@*/\n+\n+subroutine GRHydro_HLLE_TracerM(CCTK_ARGUMENTS)\n+\n+ USE GRHydro_EigenproblemM\n+\n+ implicit none\n+ \n+ DECLARE_CCTK_ARGUMENTS\n+ DECLARE_CCTK_PARAMETERS\n+ DECLARE_CCTK_FUNCTIONS\n+ \n+ integer :: i, j, k, m\n+ CCTK_REAL, dimension(number_of_tracers) :: cons_p,cons_m,fplus,fminus,f1\n+ CCTK_REAL, dimension(5) :: lamminus,lamplus\n+ CCTK_REAL, dimension(number_of_tracers) :: qdiff\n+ CCTK_REAL, dimension(7) :: prim_p, prim_m\n+ CCTK_REAL, dimension(3) :: mag_p, mag_m\n+ CCTK_REAL :: charmin, charmax, charpm,avg_alp,avg_det\n+ CCTK_REAL :: gxxh, gxyh, gxzh, gyyh, gyzh, gzzh, uxxh, uxyh, &\n+ uxzh, uyyh, uyzh, uzzh, avg_beta, usendh\n+ CCTK_REAL :: b2p,b2m\n+ \n+ CCTK_INT :: type_bits, trivial\n+\n+ ! save memory when MP is not used\n+ CCTK_INT :: GRHydro_UseGeneralCoordinates\n+ CCTK_REAL, DIMENSION(cctk_ash1,cctk_ash2,cctk_ash3) :: g11, g12, g13, g22, g23, g33\n+ pointer (pg11,g11), (pg12,g12), (pg13,g13), (pg22,g22), (pg23,g23), (pg33,g33)\n+ CCTK_REAL, DIMENSION(cctk_ash1,cctk_ash2,cctk_ash3) :: beta1, beta2, beta3\n+ pointer (pbeta1,beta1), (pbeta2,beta2), (pbeta3,beta3)\n+\n+ if (GRHydro_UseGeneralCoordinates(cctkGH).ne.0) then\n+ pg11 = loc(gaa)\n+ pg12 = loc(gab)\n+ pg13 = loc(gac)\n+ pg22 = loc(gbb)\n+ pg23 = loc(gbc)\n+ pg33 = loc(gcc)\n+ pbeta1 = loc(betaa)\n+ pbeta2 = loc(betab)\n+ pbeta3 = loc(betac)\n+ else\n+ pg11 = loc(gxx)\n+ pg12 = loc(gxy)\n+ pg13 = loc(gxz)\n+ pg22 = loc(gyy)\n+ pg23 = loc(gyz)\n+ pg33 = loc(gzz)\n+ pbeta1 = loc(betax)\n+ pbeta2 = loc(betay)\n+ pbeta3 = loc(betaz)\n+ end if\n+#define gxx faulty_gxx\n+#define gxy faulty_gxy\n+#define gxz faulty_gxz\n+#define gyy faulty_gyy\n+#define gyz faulty_gyz\n+#define gzz faulty_gzz\n+#define betax faulty_betax\n+#define betay faulty_betay\n+#define betaz faulty_betaz\n+#define vel faulty_vel\n+#define Bvec faulty_Bvec\n+\n+ if (flux_direction == 1) then\n+ call SpaceMask_GetTypeBits(type_bits, \"Hydro_RiemannProblemX\")\n+ call SpaceMask_GetStateBits(trivial, \"Hydro_RiemannProblemX\", &\n+ &\"trivial\")\n+ else if (flux_direction == 2) then\n+ call SpaceMask_GetTypeBits(type_bits, \"Hydro_RiemannProblemY\")\n+ call SpaceMask_GetStateBits(trivial, \"Hydro_RiemannProblemY\", &\n+ &\"trivial\")\n+ else if (flux_direction == 3) then\n+ call SpaceMask_GetTypeBits(type_bits, \"Hydro_RiemannProblemZ\")\n+ call SpaceMask_GetStateBits(trivial, \"Hydro_RiemannProblemZ\", &\n+ &\"trivial\")\n+ else\n+ call CCTK_ERROR(\"Flux direction not x,y,z\")\n+ STOP\n+ end if\n+\n+ do k = GRHydro_stencil, cctk_lsh(3) - GRHydro_stencil\n+ do j = GRHydro_stencil, cctk_lsh(2) - GRHydro_stencil\n+ do i = GRHydro_stencil, cctk_lsh(1) - GRHydro_stencil\n+ \n+ f1 = 0.d0\n+ lamminus = 0.d0\n+ lamplus = 0.d0\n+ cons_p = 0.d0\n+ cons_m = 0.d0\n+ mag_p = 0.d0\n+ mag_m = 0.d0\n+ fplus = 0.d0\n+ fminus = 0.d0\n+ qdiff = 0.d0\n+ \n+!!$ Set the left (p for plus) and right (m_i for minus, i+1) states\n+ \n+ cons_p(:) = cons_tracerplus(i,j,k,:) \n+ cons_m(:) = cons_tracerminus(i+xoffset,j+yoffset,k+zoffset,:)\n+ \n+ mag_p(1) = Bvecxplus(i,j,k)\n+ mag_p(2) = Bvecyplus(i,j,k)\n+ mag_p(3) = Bveczplus(i,j,k)\n+\n+ mag_m(1) = Bvecxminus(i+xoffset,j+yoffset,k+zoffset)\n+ mag_m(2) = Bvecyminus(i+xoffset,j+yoffset,k+zoffset)\n+ mag_m(3) = Bveczminus(i+xoffset,j+yoffset,k+zoffset)\n+\n+ prim_p(1) = rhoplus(i,j,k) \n+ prim_p(2) = velxplus(i,j,k)\n+ prim_p(3) = velyplus(i,j,k) \n+ prim_p(4) = velzplus(i,j,k)\n+ prim_p(5) = epsplus(i,j,k)\n+ prim_p(6) = pressplus(i,j,k)\n+ prim_p(7) = w_lorentzplus(i,j,k)\n+ \n+ prim_m(1) = rhominus(i+xoffset,j+yoffset,k+zoffset)\n+ prim_m(2) = velxminus(i+xoffset,j+yoffset,k+zoffset)\n+ prim_m(3) = velyminus(i+xoffset,j+yoffset,k+zoffset)\n+ prim_m(4) = velzminus(i+xoffset,j+yoffset,k+zoffset)\n+ prim_m(5) = epsminus(i+xoffset,j+yoffset,k+zoffset) \n+ prim_m(6) = pressminus(i+xoffset,j+yoffset,k+zoffset) \n+ prim_m(7) = w_lorentzminus(i+xoffset,j+yoffset,k+zoffset) \n+ \n+!!$ Calculate various metric terms here.\n+!!$ Note also need the average of the lapse at the \n+!!$ left and right points.\n+\n+ if (flux_direction == 1) then\n+ avg_beta = 0.5d0 * (beta1(i+xoffset,j+yoffset,k+zoffset) + &\n+ beta1(i,j,k))\n+ else if (flux_direction == 2) then\n+ avg_beta = 0.5d0 * (beta2(i+xoffset,j+yoffset,k+zoffset) + &\n+ beta2(i,j,k))\n+ else if (flux_direction == 3) then\n+ avg_beta = 0.5d0 * (beta3(i+xoffset,j+yoffset,k+zoffset) + &\n+ beta3(i,j,k))\n+ else\n+ call CCTK_ERROR(\"Flux direction not x,y,z\")\n+ STOP\n+ end if\n+\n+ avg_alp = 0.5 * (alp(i,j,k) + alp(i+xoffset,j+yoffset,k+zoffset))\n+ \n+ gxxh = 0.5d0 * (g11(i+xoffset,j+yoffset,k+zoffset) + g11(i,j,k))\n+ gxyh = 0.5d0 * (g12(i+xoffset,j+yoffset,k+zoffset) + g12(i,j,k))\n+ gxzh = 0.5d0 * (g13(i+xoffset,j+yoffset,k+zoffset) + g13(i,j,k))\n+ gyyh = 0.5d0 * (g22(i+xoffset,j+yoffset,k+zoffset) + g22(i,j,k))\n+ gyzh = 0.5d0 * (g23(i+xoffset,j+yoffset,k+zoffset) + g23(i,j,k))\n+ gzzh = 0.5d0 * (g33(i+xoffset,j+yoffset,k+zoffset) + g33(i,j,k))\n+\n+ avg_det = SPATIAL_DETERMINANT(gxxh,gxyh,gxzh,gyyh,gyzh,gzzh)\n+\n+ call UpperMetric(uxxh, uxyh, uxzh, uyyh, uyzh, uzzh, &\n+ avg_det,gxxh, gxyh, gxzh, &\n+ gyyh, gyzh, gzzh)\n+ \n+ if (flux_direction == 1) then\n+ usendh = uxxh\n+ else if (flux_direction == 2) then\n+ usendh = uyyh\n+ else if (flux_direction == 3) then\n+ usendh = uzzh\n+ else\n+ call CCTK_ERROR(\"Flux direction not x,y,z\")\n+ STOP\n+ end if\n+\n+!!$ b^2 = (1-v^2)B^2+(B dot v)^2 \n+ b2p=DOTP2(gxxh,gxyh,gxzh,gyyh,gyzh,gzzh,mag_p(1),mag_p(2),mag_p(3))/prim_p(7)**2 + &\n+ (DOTP(gxxh,gxyh,gxzh,gyyh,gyzh,gzzh,prim_p(2),prim_p(3),prim_p(4),mag_p(1),mag_p(2),mag_p(3)))**2\n+ b2m=DOTP2(gxxh,gxyh,gxzh,gyyh,gyzh,gzzh,mag_m(1),mag_m(2),mag_m(3))/prim_m(7)**2 + &\n+ (DOTP(gxxh,gxyh,gxzh,gyyh,gyzh,gzzh,prim_m(2),prim_m(3),prim_m(4),mag_m(1),mag_m(2),mag_m(3)))**2\n+ \n+!!$ Calculate the jumps in the conserved variables\n+ \n+ qdiff = cons_m - cons_p\n+ \n+!!$ Eigenvalues and fluxes either side of the cell interface\n+ \n+ if (flux_direction == 1) then\n+ call eigenvaluesM(GRHydro_eos_handle,&\n+ prim_m(1),prim_m(2),prim_m(3),prim_m(4),prim_m(5),prim_m(6),prim_m(7), &\n+ mag_m(1),mag_m(2),mag_m(3),&\n+ lamminus,gxxh,gxyh,gxzh,gyyh,gyzh,gzzh,&\n+ usendh,avg_alp,avg_beta) \n+ call eigenvaluesM(GRHydro_eos_handle, &\n+ prim_p(1),prim_p(2),prim_p(3),prim_p(4),prim_p(5),prim_p(6),prim_p(7), &\n+ mag_p(1),mag_p(2),mag_p(3),&\n+ lamplus,gxxh,gxyh,gxzh,gyyh,gyzh,gzzh,&\n+ usendh,avg_alp,avg_beta)\n+ fplus(:) = (velxplus(i,j,k) - avg_beta / avg_alp) * &\n+ cons_tracerplus(i,j,k,:)\n+ fminus(:) = (velxminus(i+xoffset,j+yoffset,k+zoffset) - avg_beta / avg_alp) * &\n+ cons_tracerminus(i+xoffset,j+yoffset,k+zoffset,:)\n+ else if (flux_direction == 2) then\n+ call eigenvaluesM(GRHydro_eos_handle,&\n+ prim_m(1),prim_m(3),prim_m(4),prim_m(2),prim_m(5),prim_m(6),prim_m(7), &\n+ mag_m(2),mag_m(3),mag_m(1),&\n+ lamminus,gyyh,gyzh,gxyh,gzzh,gxzh,gxxh,&\n+ usendh,avg_alp,avg_beta) \n+ call eigenvaluesM(GRHydro_eos_handle, &\n+ prim_p(1),prim_p(3),prim_p(4),prim_p(2),prim_p(5),prim_p(6),prim_p(7), &\n+ mag_p(2),mag_p(3),mag_p(1),&\n+ lamplus,gyyh,gyzh,gxyh,gzzh,gxzh,gxxh,&\n+ usendh,avg_alp,avg_beta)\n+ fplus(:) = (velyplus(i,j,k) - avg_beta / avg_alp) * &\n+ cons_tracerplus(i,j,k,:)\n+ fminus(:) = (velyminus(i+xoffset,j+yoffset,k+zoffset) - avg_beta / avg_alp) * &\n+ cons_tracerminus(i+xoffset,j+yoffset,k+zoffset,:)\n+ else if (flux_direction == 3) then\n+ call eigenvaluesM(GRHydro_eos_handle,&\n+ prim_m(1),prim_m(4),prim_m(2),prim_m(3),prim_m(5),prim_m(6),prim_m(7), &\n+ mag_m(3),mag_m(1),mag_m(2),&\n+ lamminus,gzzh,gxzh,gyzh,gxxh,gxyh,gyyh,&\n+ usendh,avg_alp,avg_beta) \n+ call eigenvaluesM(GRHydro_eos_handle,&\n+ prim_p(1),prim_p(4),prim_p(2),prim_p(3),prim_p(5),prim_p(6),prim_p(7), &\n+ mag_p(3),mag_p(1),mag_p(2),&\n+ lamplus,gzzh,gxzh,gyzh,gxxh,gxyh,gyyh,&\n+ usendh,avg_alp,avg_beta)\n+ fplus(:) = (velzplus(i,j,k) - avg_beta / avg_alp) * &\n+ cons_tracerplus(i,j,k,:)\n+ fminus(:) = (velzminus(i+xoffset,j+yoffset,k+zoffset) - avg_beta / avg_alp) * &\n+ cons_tracerminus(i+xoffset,j+yoffset,k+zoffset,:)\n+ else\n+ call CCTK_ERROR(\"Flux direction not x,y,z\")\n+ STOP\n+ end if\n+ \n+!!$ Find minimum and maximum wavespeeds\n+ \n+ charmin = min(0.d0, lamplus(1), lamplus(2), lamplus(3), &\n+ lamplus(4),lamplus(5), lamminus(1),lamminus(2),lamminus(3),&\n+ lamminus(4),lamminus(5)) \n+ \n+ charmax = max(0.d0, lamplus(1), lamplus(2), lamplus(3), &\n+ lamplus(4),lamplus(5), lamminus(1),lamminus(2),lamminus(3),&\n+ lamminus(4),lamminus(5))\n+ \n+ charpm = charmax - charmin\n+ \n+!!$ Calculate flux by standard formula\n+ \n+ do m = 1,number_of_tracers\n+ \n+ qdiff(m) = cons_m(m) - cons_p(m)\n+ \n+ f1(m) = (charmax * fplus(m) - charmin * fminus(m) + &\n+ charmax * charmin * qdiff(m)) / charpm\n+ \n+ end do\n+ \n+ cons_tracerflux(i, j, k,:) = f1(:)\n+!!$\n+!!$ if ( ((flux_direction.eq.3).and.(i.eq.4).and.(j.eq.4)).or.&\n+!!$ ((flux_direction.eq.2).and.(i.eq.4).and.(k.eq.4)).or.&\n+!!$ ((flux_direction.eq.1).and.(j.eq.4).and.(k.eq.4))&\n+!!$ ) then\n+!!$ write(*,*) flux_direction, i, j, k, f1(1), cons_m(1), cons_p(1)\n+!!$ end if\n+ \n+ end do\n+ end do\n+end do\n+#undef faulty_gxx\n+#undef faulty_gxy\n+#undef faulty_gxz\n+#undef faulty_gyy\n+#undef faulty_gyz\n+#undef faulty_gzz\n+#undef faulty_betax\n+#undef faulty_betay\n+#undef faulty_betaz\n+#undef faulty_vel\n+#undef faulty_Bvec\n+\n+\n+end subroutine GRHydro_HLLE_TracerM\n+" }
{ "test_patch": "diff --git a/all_tests.txt b/all_tests.txt\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/all_tests.txt\n@@ -0,0 +1,10 @@\n+GRHydro_test_shock\n+GRHydro_test_shock_mp5\n+GRHydro_test_shock_ppm\n+GRHydro_test_tov_ppm_ML\n+GRHydro_test_tov_ppm_ML_disable_internal_excision\n+GRHydro_test_tov_ppm_no_trp_ML\n+test_one_hybrid\n+tov_carpetevolutionmask\n+tov_carpetevolutionmask2\n+tov_slowsector", "pass_criteria": "all_tests_pass" }
{ "scoring_method": "binary", "resolve_points": 100 }
MSB_einsteintoolkit_Cactus_pr15
multi_swe_bench
Add missing GRHydro_Tmunu.F90 in EinsteinEvolve/GRHydro (einsteintoolkit/Cactus#15)
{ "org": "einsteintoolkit", "repo": "Cactus", "pr_number": 15, "issue_title": "Add missing GRHydro_Tmunu.F90 in EinsteinEvolve/GRHydro", "issue_body": "This PR adds the missing source file GRHydro_Tmunu.F90 to complete the EinsteinEvolve/GRHydro thorn implementation.", "base_commit": "HEAD", "resolved_issues": [ { "number": 15, "title": "Implement the full functionality of GRHydro", "body": "Please implement the full functionality of `GRHydro` by finishing the code in `GRHydro_Tmunu.F90`.\n\n## Thorn Information:\n- Name: GRHydro\n- Target file: GRHydro_Tmunu.F90\n\n## Interface Definition in interface.ccl:\n\n## Schedule Definition in schedule.ccl:\n\n## Parameters Definition in param.ccl:\n\n## Configuration Definition in configuration.ccl:\n\n## Documentation Context in readme.md and doc/documentation.tex\n\n## Related Code Context in src folder\n\n" } ], "commits": [], "diff_url": "", "patch_url": "", "html_url": "", "created_at": "", "merged_at": "" }
{ "env_type": "docker", "docker_image": "mswebench/einsteintoolkit_m_cactus:pr-15", "working_directory": "/testbed", "needs_build": true }
{ "fix_patch": "diff --git a/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_Tmunu.F90 b/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_Tmunu.F90\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_Tmunu.F90\n@@ -0,0 +1,159 @@\n+ /*@@\n+ @file GRHydro_Tmunu.F90\n+ @date Thu Apr 16 19:38:40 2009\n+ @author Ian Hawke\n+ @histpry\n+ Apr. 2009: Luca Baiotti copied and adapted for the Tmunu-thorn mechanism the original include file\n+ @desc \n+ The calculation of the stress energy tensor.\n+ The version used here was worked out by Miguel Alcubierre. I\n+ think it was an extension of the routine from GR3D, written\n+ by Mark Miller.\n+ C version added by Ian Hawke.\n+\n+ Lower components of the stress-energy tensor obtained from\n+ the hydro variables. The components are given by:\n+\n+ T = rho h u u + P g\n+ mu nu mu nu mu nu\n+\n+ where rho is the energy density of the fluid, h the enthalpy\n+ and P the pressure. The enthalpy is given in terms of the\n+ basic variables as:\n+\n+ h = 1 + e + P/rho\n+\n+ with e the internal energy (eps here).\n+\n+ In the expresion for T_{mu,nu} we also have the four-velocity\n+ of the fluid given by (v_i is the 3-velocity field):\n+\n+ i\n+ u = W ( - alpha + v beta )\n+ 0 i\n+\n+ u = W v\n+ i i\n+ i -1/2\n+ with W the Lorentz factor: W = ( 1 - v v )\n+ i\n+\n+ and where alpha and beta are the lapse and shift vector.\n+\n+ Finally, the 4 metric is given by\n+\n+ 2 i\n+ g = - alpha + beta beta\n+ 00 i\n+\n+ g = beta\n+ 0i i\n+\n+\n+ g = gamma (the spatial metric)\n+ ij ij\n+\n+\n+ @enddesc \n+ @@*/\n+#include \"cctk.h\"\n+#include \"cctk_Arguments.h\"\n+#include \"cctk_Parameters.h\"\n+#include \"cctk_Functions.h\"\n+#include \"SpaceMask.h\"\n+\n+#define velx(i,j,k) vel(i,j,k,1)\n+#define vely(i,j,k) vel(i,j,k,2)\n+#define velz(i,j,k) vel(i,j,k,3)\n+\n+ subroutine GRHydro_Tmunu(CCTK_ARGUMENTS)\n+\n+ implicit none\n+\n+ DECLARE_CCTK_ARGUMENTS\n+ DECLARE_CCTK_PARAMETERS\n+ DECLARE_CCTK_FUNCTIONS\n+\n+ CCTK_REAL velxlow, velylow, velzlow\n+ CCTK_REAL betaxlow, betaylow, betazlow, beta2\n+ CCTK_REAL utlow, uxlow, uylow, uzlow\n+ CCTK_REAL rhoenthalpy\n+ CCTK_REAL ut,ux,uy,uz,bst,bsx,bsy,bsz,bs2\n+ CCTK_REAL dampfac\n+ CCTK_INT i,j,k\n+\n+!!$ Damping factor\n+ dampfac = 1.0\n+\n+ !$OMP PARALLEL DO PRIVATE(i,j,k,velxlow, velylow, velzlow,&\n+ !$OMP betaxlow, betaylow, betazlow, beta2, utlow, uxlow, uylow, uzlow,&\n+ !$OMP rhoenthalpy, ut,ux,uy,uz,bst,bsx,bsy,bsz,bs2,dampfac)\n+ do k = 1, cctk_lsh(3)\n+ do j = 1, cctk_lsh(2)\n+ do i = 1, cctk_lsh(1)\n+\n+ velxlow = gxx(i,j,k)*velx(i,j,k) + gxy(i,j,k)*vely(i,j,k) + gxz(i,j,k)*velz(i,j,k)\n+ velylow = gxy(i,j,k)*velx(i,j,k) + gyy(i,j,k)*vely(i,j,k) + gyz(i,j,k)*velz(i,j,k)\n+ velzlow = gxz(i,j,k)*velx(i,j,k) + gyz(i,j,k)*vely(i,j,k) + gzz(i,j,k)*velz(i,j,k)\n+\n+!!$ Calculate lower components and square of shift vector.\n+\n+ betaxlow = gxx(i,j,k)*betax(i,j,k) + gxy(i,j,k)*betay(i,j,k) + gxz(i,j,k)*betaz(i,j,k)\n+ betaylow = gxy(i,j,k)*betax(i,j,k) + gyy(i,j,k)*betay(i,j,k) + gyz(i,j,k)*betaz(i,j,k)\n+ betazlow = gxz(i,j,k)*betax(i,j,k) + gyz(i,j,k)*betay(i,j,k) + gzz(i,j,k)*betaz(i,j,k)\n+ \n+ beta2 = betax(i,j,k)*betaxlow + betay(i,j,k)*betaylow + betaz(i,j,k)*betazlow \n+ \n+!!$ Calculate the specific relativistic enthalpy times rho times the\n+!!$ square of the lorentz factor.\n+\n+ rhoenthalpy = w_lorentz(i,j,k)**2*(rho(i,j,k)*(1.0d0 + eps(i,j,k)) + press(i,j,k))\n+\n+!!$ Calculate lower components of 4-velocity (without the Lorent factor).\n+\n+ utlow = (-alp(i,j,k) + velx(i,j,k)*betaxlow + vely(i,j,k)*betaylow + velz(i,j,k)*betazlow)\n+\n+ uxlow = velxlow\n+ uylow = velylow\n+ uzlow = velzlow\n+\n+\n+!!$ Initialize damping factor\n+ dampfac = 1.0\n+!!$ Apply tanh blending for Tmunu.\n+ if ((Tmunu_damping_radius_min .gt. 0) .and. (r(i,j,k) .gt. Tmunu_damping_radius_min)) then\n+ ! 0.5 * (1.0 - tanh(4.0*(x-x0)/sigma0))\n+ if (r(i,j,k) .lt. Tmunu_damping_radius_max) then\n+ dampfac = 0.5d0 * (1.0d0 - tanh((8.0d0*r(i,j,k)-4.0d0*(Tmunu_damping_radius_max+Tmunu_damping_radius_min))/(Tmunu_damping_radius_max-Tmunu_damping_radius_min)))\n+ else\n+ dampfac = 0.0\n+ continue ! no need to add anything to Tmunu at the current point (it's zero anyway!)\n+ endif\n+ else\n+ dampfac = 1.0\n+ endif\n+ \n+!!$ Calculate Tmunu (the lower components!).\n+\n+ eTtt(i,j,k) = eTtt(i,j,k) + dampfac * (rhoenthalpy*utlow**2 + press(i,j,k)*(beta2 - alp(i,j,k)**2))\n+\n+ eTtx(i,j,k) = eTtx(i,j,k) + dampfac * (rhoenthalpy*utlow*uxlow + press(i,j,k)*betaxlow)\n+ eTty(i,j,k) = eTty(i,j,k) + dampfac * (rhoenthalpy*utlow*uylow + press(i,j,k)*betaylow)\n+ eTtz(i,j,k) = eTtz(i,j,k) + dampfac * (rhoenthalpy*utlow*uzlow + press(i,j,k)*betazlow)\n+\n+ eTxx(i,j,k) = eTxx(i,j,k) + dampfac * (rhoenthalpy*uxlow**2 + press(i,j,k)*gxx(i,j,k))\n+ eTyy(i,j,k) = eTyy(i,j,k) + dampfac * (rhoenthalpy*uylow**2 + press(i,j,k)*gyy(i,j,k))\n+ eTzz(i,j,k) = eTzz(i,j,k) + dampfac * (rhoenthalpy*uzlow**2 + press(i,j,k)*gzz(i,j,k))\n+ \n+ eTxy(i,j,k) = eTxy(i,j,k) + dampfac * (rhoenthalpy*uxlow*uylow + press(i,j,k)*gxy(i,j,k))\n+ eTxz(i,j,k) = eTxz(i,j,k) + dampfac * (rhoenthalpy*uxlow*uzlow + press(i,j,k)*gxz(i,j,k))\n+ eTyz(i,j,k) = eTyz(i,j,k) + dampfac * (rhoenthalpy*uylow*uzlow + press(i,j,k)*gyz(i,j,k))\n+\n+ end do\n+ end do\n+ end do\n+ !$OMP END PARALLEL DO\n+\n+ return\n+ \n+ end subroutine GRHydro_Tmunu" }
{ "test_patch": "diff --git a/all_tests.txt b/all_tests.txt\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/all_tests.txt\n@@ -0,0 +1,10 @@\n+GRHydro_test_shock\n+GRHydro_test_shock_mp5\n+GRHydro_test_shock_ppm\n+GRHydro_test_tov_ppm_ML\n+GRHydro_test_tov_ppm_ML_disable_internal_excision\n+GRHydro_test_tov_ppm_no_trp_ML\n+test_one_hybrid\n+tov_carpetevolutionmask\n+tov_carpetevolutionmask2\n+tov_slowsector", "pass_criteria": "all_tests_pass" }
{ "scoring_method": "binary", "resolve_points": 100 }
MSB_einsteintoolkit_Cactus_pr16
multi_swe_bench
Add missing GRHydro_TmunuM.F90 in EinsteinEvolve/GRHydro (einsteintoolkit/Cactus#16)
{ "org": "einsteintoolkit", "repo": "Cactus", "pr_number": 16, "issue_title": "Add missing GRHydro_TmunuM.F90 in EinsteinEvolve/GRHydro", "issue_body": "This PR adds the missing source file GRHydro_TmunuM.F90 to complete the EinsteinEvolve/GRHydro thorn implementation.", "base_commit": "HEAD", "resolved_issues": [ { "number": 16, "title": "Implement the full functionality of GRHydro", "body": "Please implement the full functionality of `GRHydro` by finishing the code in `GRHydro_TmunuM.F90`.\n\n## Thorn Information:\n- Name: GRHydro\n- Target file: GRHydro_TmunuM.F90\n\n## Interface Definition in interface.ccl:\n\n## Schedule Definition in schedule.ccl:\n\n## Parameters Definition in param.ccl:\n\n## Configuration Definition in configuration.ccl:\n\n## Documentation Context in readme.md and doc/documentation.tex\n\n## Related Code Context in src folder\n\n" } ], "commits": [], "diff_url": "", "patch_url": "", "html_url": "", "created_at": "", "merged_at": "" }
{ "env_type": "docker", "docker_image": "mswebench/einsteintoolkit_m_cactus:pr-16", "working_directory": "/testbed", "needs_build": true }
{ "fix_patch": "diff --git a/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_TmunuM.F90 b/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_TmunuM.F90\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_TmunuM.F90\n@@ -0,0 +1,167 @@\n+ /*@@\n+ @file GRHydro_Tmunu.F90\n+ @date Aug 30, 2010\n+ @author Joshua Faber, Scott Noble, Bruno Mundim, Ian Hawke\n+ @histpry\n+ Apr. 2009: Luca Baiotti copied and adapted for the Tmunu-thorn mechanism the original include file\n+ @desc \n+ The calculation of the stress energy tensor.\n+ The version used here was worked out by Miguel Alcubierre. I\n+ think it was an extension of the routine from GR3D, written\n+ by Mark Miller.\n+ C version added by Ian Hawke.\n+\n+ Lower components of the stress-energy tensor obtained from\n+ the hydro variables. The components are given by:\n+\n+ T = (rho h +b^2) u u + (P+b^2/2) g - b b\n+ mu nu mu nu mu nu mu nu \n+\n+ where rho is the energy density of the fluid, h the enthalpy\n+ and P the pressure. The enthalpy is given in terms of the\n+ basic variables as:\n+\n+ h = 1 + e + P/rho\n+\n+ with e the internal energy (eps here).\n+\n+ In the expresion for T_{mu,nu} we also have the four-velocity\n+ of the fluid given by (v_i is the 3-velocity field):\n+\n+ i\n+ u = W ( - alpha + v beta )\n+ 0 i\n+\n+ u = W v\n+ i i\n+ i -1/2\n+ with W the Lorentz factor: W = ( 1 - v v )\n+ i\n+\n+ and where alpha and beta are the lapse and shift vector.\n+\n+ Finally, the 4 metric is given by\n+\n+ 2 i\n+ g = - alpha + beta beta\n+ 00 i\n+\n+ g = beta\n+ 0i i\n+\n+\n+ g = gamma (the spatial metric)\n+ ij ij\n+\n+\n+ @enddesc \n+ @@*/\n+#include \"cctk.h\"\n+#include \"cctk_Arguments.h\"\n+#include \"cctk_Parameters.h\"\n+#include \"cctk_Functions.h\"\n+#include \"SpaceMask.h\"\n+\n+#define velx(i,j,k) vel(i,j,k,1)\n+#define vely(i,j,k) vel(i,j,k,2)\n+#define velz(i,j,k) vel(i,j,k,3)\n+#define Bvecx(i,j,k) Bvec(i,j,k,1)\n+#define Bvecy(i,j,k) Bvec(i,j,k,2)\n+#define Bvecz(i,j,k) Bvec(i,j,k,3)\n+#define bcomx(i,j,k) bcom(i,j,k,1)\n+#define bcomy(i,j,k) bcom(i,j,k,2)\n+#define bcomz(i,j,k) bcom(i,j,k,3)\n+\n+ subroutine GRHydro_TmunuM(CCTK_ARGUMENTS)\n+\n+ implicit none\n+\n+ DECLARE_CCTK_ARGUMENTS\n+ DECLARE_CCTK_PARAMETERS\n+ DECLARE_CCTK_FUNCTIONS\n+\n+ CCTK_REAL :: velxlow, velylow, velzlow\n+ CCTK_REAL :: betaxlow, betaylow, betazlow, beta2\n+ CCTK_REAL :: Bvecxlow,Bvecylow,Bveczlow\n+ CCTK_REAL :: bdotv,b2,bxlow,bylow,bzlow,btlow,dum1,dum2\n+ CCTK_REAL :: utlow,rhohstarw2,pstar\n+ CCTK_REAL :: bdotbeta,vdotbeta\n+ CCTK_INT :: i,j,k\n+\n+\n+ !$OMP PARALLEL DO PRIVATE(i,j,k,velxlow, velylow, velzlow,&\n+ !$OMP Bvecxlow,Bvecylow,Bveczlow, bdotv,dum1,dum2,b2,bxlow,bylow,bzlow,&\n+ !$OMP betaxlow, betaylow, betazlow, beta2, bdotbeta,vdotbeta,utlow, btlow,&\n+ !$OMP rhohstarw2,pstar)\n+\n+ do k = 1, cctk_lsh(3)\n+ do j = 1, cctk_lsh(2)\n+ do i = 1, cctk_lsh(1)\n+\n+ ! need separate dum1, dum2 b/c of Fortrans aliasing rules\n+ call calc_vlow_blow(gxx(i,j,k),gxy(i,j,k),gxz(i,j,k),&\n+ gyy(i,j,k),gyz(i,j,k),gzz(i,j,k), &\n+ velx(i,j,k),vely(i,j,k),velz(i,j,k),Bvecx(i,j,k),Bvecy(i,j,k),Bvecz(i,j,k), &\n+ velxlow,velylow,velzlow,Bvecxlow,Bvecylow,Bveczlow, &\n+ bdotv,b2,dum1,dum2,bxlow,bylow,bzlow)\n+ \n+!!$ Calculate lower components and square of shift vector.\n+ \n+ \n+ betaxlow = gxx(i,j,k)*betax(i,j,k) + gxy(i,j,k)*betay(i,j,k) + gxz(i,j,k)*betaz(i,j,k)\n+ betaylow = gxy(i,j,k)*betax(i,j,k) + gyy(i,j,k)*betay(i,j,k) + gyz(i,j,k)*betaz(i,j,k)\n+ betazlow = gxz(i,j,k)*betax(i,j,k) + gyz(i,j,k)*betay(i,j,k) + gzz(i,j,k)*betaz(i,j,k)\n+ beta2 = betax(i,j,k)*betaxlow + betay(i,j,k)*betaylow + betaz(i,j,k)*betazlow \n+ \n+ bdotbeta = betaxlow*Bvecx(i,j,k)+betaylow*Bvecy(i,j,k)+betazlow*Bvecz(i,j,k)\n+ vdotbeta = betaxlow*velx(i,j,k)+betaylow*vely(i,j,k)+betazlow*velz(i,j,k)\n+\n+!!$ u0 low is missing the w_lorentz factor (see below)!!\n+ utlow = -1.d0*alp(i,j,k) + vdotbeta\n+ \n+ btlow = -1.0d0*w_lorentz(i,j,k)*alp(i,j,k)*bdotv + &\n+ bdotbeta/w_lorentz(i,j,k) + w_lorentz(i,j,k)*bdotv*vdotbeta\n+\n+!!$ Calculate the specific relativistic enthalpy times rho + the mag. field contribution times the\n+!!$ square of the lorentz factor.\n+\n+ rhohstarw2 = w_lorentz(i,j,k)**2*(rho(i,j,k)*(1.0d0 + eps(i,j,k)) + press(i,j,k) + b2)\n+ pstar = press(i,j,k)+0.5d0*b2\n+\n+!!$ Calculate lower components of 4-velocity (without the Lorent factor).\n+!!$ uxlow = velxlow\n+!!$ uylow = velylow\n+!!$ uzlow = velzlow\n+\n+!!$ Calculate Tmunu (the lower components!).\n+\n+ eTtt(i,j,k) = eTtt(i,j,k) + rhohstarw2*utlow**2 + pstar*(beta2 - alp(i,j,k)**2) - btlow**2\n+\n+ eTtx(i,j,k) = eTtx(i,j,k) + rhohstarw2*utlow*velxlow + pstar*betaxlow - btlow*bxlow\n+ eTty(i,j,k) = eTty(i,j,k) + rhohstarw2*utlow*velylow + pstar*betaylow - btlow*bylow\n+ eTtz(i,j,k) = eTtz(i,j,k) + rhohstarw2*utlow*velzlow + pstar*betazlow - btlow*bzlow\n+\n+ eTxx(i,j,k) = eTxx(i,j,k) + rhohstarw2*velxlow**2 + pstar*gxx(i,j,k) - bxlow**2\n+ eTyy(i,j,k) = eTyy(i,j,k) + rhohstarw2*velylow**2 + pstar*gyy(i,j,k) - bylow**2\n+ eTzz(i,j,k) = eTzz(i,j,k) + rhohstarw2*velzlow**2 + pstar*gzz(i,j,k) - bzlow**2\n+ \n+ eTxy(i,j,k) = eTxy(i,j,k) + rhohstarw2*velxlow*velylow + pstar*gxy(i,j,k) - bxlow*bylow\n+ eTxz(i,j,k) = eTxz(i,j,k) + rhohstarw2*velxlow*velzlow + pstar*gxz(i,j,k) - bxlow*bzlow\n+ eTyz(i,j,k) = eTyz(i,j,k) + rhohstarw2*velylow*velzlow + pstar*gyz(i,j,k) - bylow*bzlow\n+\n+ if(calculate_bcom .ne. 0) then\n+ bcom_sq(i,j,k) = b2 \n+ bcom0(i,j,k) = w_lorentz(i,j,k)*bdotv/alp(i,j,k)\n+ bcomx(i,j,k) = Bvecx(i,j,k)/w_lorentz(i,j,k) + bcom0(i,j,k)*(alp(i,j,k)*velx(i,j,k)-betax(i,j,k))\n+ bcomy(i,j,k) = Bvecy(i,j,k)/w_lorentz(i,j,k) + bcom0(i,j,k)*(alp(i,j,k)*vely(i,j,k)-betay(i,j,k))\n+ bcomz(i,j,k) = Bvecz(i,j,k)/w_lorentz(i,j,k) + bcom0(i,j,k)*(alp(i,j,k)*velz(i,j,k)-betaz(i,j,k))\n+ endif \n+\n+ end do\n+ end do\n+ end do\n+ !$OMP END PARALLEL DO\n+\n+ return\n+ \n+ end subroutine GRHydro_TmunuM" }
{ "test_patch": "diff --git a/all_tests.txt b/all_tests.txt\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/all_tests.txt\n@@ -0,0 +1,10 @@\n+GRHydro_test_shock\n+GRHydro_test_shock_mp5\n+GRHydro_test_shock_ppm\n+GRHydro_test_tov_ppm_ML\n+GRHydro_test_tov_ppm_ML_disable_internal_excision\n+GRHydro_test_tov_ppm_no_trp_ML\n+test_one_hybrid\n+tov_carpetevolutionmask\n+tov_carpetevolutionmask2\n+tov_slowsector", "pass_criteria": "all_tests_pass" }
{ "scoring_method": "binary", "resolve_points": 100 }
MSB_einsteintoolkit_Cactus_pr17
multi_swe_bench
Add missing GRHydro_Minima.cc in EinsteinEvolve/GRHydro (einsteintoolkit/Cactus#17)
{ "org": "einsteintoolkit", "repo": "Cactus", "pr_number": 17, "issue_title": "Add missing GRHydro_Minima.cc in EinsteinEvolve/GRHydro", "issue_body": "This PR adds the missing source file GRHydro_Minima.cc to complete the EinsteinEvolve/GRHydro thorn implementation.", "base_commit": "HEAD", "resolved_issues": [ { "number": 17, "title": "Implement the full functionality of GRHydro", "body": "Please implement the full functionality of `GRHydro` by finishing the code in `GRHydro_Minima.cc`.\n\n## Thorn Information:\n- Name: GRHydro\n- Target file: GRHydro_Minima.cc\n\n## Interface Definition in interface.ccl:\n\n## Schedule Definition in schedule.ccl:\n\n## Parameters Definition in param.ccl:\n\n## Configuration Definition in configuration.ccl:\n\n## Documentation Context in readme.md and doc/documentation.tex\n\n## Related Code Context in src folder\n\n" } ], "commits": [], "diff_url": "", "patch_url": "", "html_url": "", "created_at": "", "merged_at": "" }
{ "env_type": "docker", "docker_image": "mswebench/einsteintoolkit_m_cactus:pr-17", "working_directory": "/testbed", "needs_build": true }
{ "fix_patch": "diff --git a/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_Minima.cc b/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_Minima.cc\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_Minima.cc\n@@ -0,0 +1,175 @@\n+ /*@@\n+ @file GRHydro_Minima.cc\n+ @date Tue Aug 29 18:52:10 2006\n+ @author \n+ @desc \n+ Sets up the scalars used for the atmosphere, after initial data.\n+ @enddesc \n+ @@*/\n+\n+#include \"cctk.h\"\n+#include \"cctk_Parameters.h\"\n+#include \"cctk_Arguments.h\"\n+\n+//#include \"Carpet/Carpet/src/carpet.hh\"\n+#include \"carpet.hh\"\n+\n+#ifdef HAVE_CARPET\n+using namespace Carpet;\n+#endif\n+\n+#ifdef __cplusplus\n+ extern \"C\" {\n+#endif\n+ \n+ /* Scheduled functions */\n+ void GRHydro_Rho_Minima_Setup_Final(CCTK_ARGUMENTS);\n+\n+ void GRHydro_Rho_Minima_Setup_Final_PUGH(CCTK_ARGUMENTS);\n+ \n+#ifdef __cplusplus\n+ } /* extern \"C\" */\n+#endif\n+\n+ /*@@\n+ @routine GRHydro_Rho_Minima_Setup_Final\n+ @date Tue Aug 29 18:54:05 2006\n+ @author Luca Baiotti\n+ @desc \n+ After initial data, set up the scalar GRHydro_rho_min used for checking the atmosphere.\n+ This is computed taking into account the actual maximum rest-mass density on the grid.\n+ Version for Carpet.\n+ @enddesc \n+ @calls \n+ @calledby \n+ @history \n+ \n+ @endhistory \n+@@*/\n+\n+void GRHydro_Rho_Minima_Setup_Final(CCTK_ARGUMENTS)\n+{\n+\n+#ifdef HAVE_CARPET\n+\n+ DECLARE_CCTK_ARGUMENTS;\n+ DECLARE_CCTK_PARAMETERS;\n+\n+ CCTK_REAL max_rho;\n+\n+ static int flag = true;\n+ \n+ if (flag) // Actually run this reduction only the first time the routine is called.\n+ {\n+ if (rho_abs_min > 0.0)\n+ {\n+ *GRHydro_rho_min = rho_abs_min;\n+ }\n+ else\n+ { \n+ // Go to global mode\n+\n+ BEGIN_GLOBAL_MODE (cctkGH) {\n+\n+ // Find the global maximum of rho\n+\n+ const int Reduction_Handle = CCTK_ReductionHandle (\"maximum\");\n+ \n+ const CCTK_INT input_array_variable_indices= {CCTK_VarIndex(\"HydroBase::rho\")};\n+ \n+ const int ierr = CCTK_Reduce(cctkGH,\n+ -1, // target processors; -1 -> all\n+ Reduction_Handle,\n+ 1, // number of output variables\n+ CCTK_VARIABLE_REAL,\n+ &max_rho,\n+ 1, // number of variables to be reduced\n+ input_array_variable_indices);\n+ \n+ if (ierr != 0)\n+ {\n+ CCTK_WARN(0, \"Failed to compute the global maximum of rho\");\n+ }\n+ \n+ *GRHydro_rho_min = max_rho * rho_rel_min;\n+ \n+ // Go back to local mode\n+ } END_GLOBAL_MODE;\n+ \n+ }\n+ // After this has run once, set the flag so that this does not run again\n+ flag = false;\n+ } // end if (flag)\n+ else\n+ {\n+ return;\n+ }\n+\n+#endif\n+\n+ //Debug stuff\n+ // char warnline;\n+\n+ //CCTK_VInfo (CCTK_THORNSTRING, \"STEP 2: compute rho max; rho min: %13.12e \\n\",*GRHydro_rho_min);\n+\n+ // printf(warnline,\"STEP 2: compute rho max; rho min: %13.12e \\n\",*GRHydro_rho_min);\n+ //CCTK_WARN(1,warnline);\n+\n+ // printf(warnline,\"STEP 3: recompute ID with new atmosphere; rho min: ', GRHydro_rho_min, 'reflev: ',%i), GRHydro_rho_min, GRHydro_reflevel);\n+\n+\n+\n+}\n+\n+\n+ /*@@\n+ @routine GRHydro_Rho_Minima_Setup_Final_PUGH\n+ @date Tue Aug 29 18:57:42 2006\n+ @author Luca Baiotti\n+ @desc \n+ As above, but for PUGH.\n+ @enddesc \n+ @calls \n+ @calledby \n+ @history \n+ \n+ @endhistory \n+@@*/\n+\n+void GRHydro_Rho_Minima_Setup_Final_PUGH(CCTK_ARGUMENTS)\n+{ \n+ DECLARE_CCTK_ARGUMENTS;\n+ DECLARE_CCTK_PARAMETERS;\n+ \n+ CCTK_REAL max_rho;\n+ \n+ if (rho_abs_min > 0.0)\n+ {\n+ *GRHydro_rho_min = rho_abs_min;\n+ }\n+ else\n+ { \n+ // Find the global maximum of rho\n+ \n+ const int Reduction_Handle = CCTK_ReductionHandle(\"maximum\");\n+ \n+ const CCTK_INT input_array_variable_indices={CCTK_VarIndex(\"HydroBase::rho\")};\n+ \n+ const int ierr = CCTK_Reduce(cctkGH,\n+ -1, // target processors; -1 -> all\n+ Reduction_Handle,\n+ 1, // number of output variables \n+ CCTK_VARIABLE_REAL,\n+ &max_rho,\n+ 1, // number of variables to be reduced\n+ input_array_variable_indices);\n+ \n+ if (ierr != 0)\n+ {\n+ CCTK_WARN(0, \"Failed to compute the global maximum of rho\");\n+ }\n+ \n+ *GRHydro_rho_min = max_rho * rho_rel_min; \n+ }\n+}\n+" }
{ "test_patch": "diff --git a/all_tests.txt b/all_tests.txt\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/all_tests.txt\n@@ -0,0 +1,10 @@\n+GRHydro_test_shock\n+GRHydro_test_shock_mp5\n+GRHydro_test_shock_ppm\n+GRHydro_test_tov_ppm_ML\n+GRHydro_test_tov_ppm_ML_disable_internal_excision\n+GRHydro_test_tov_ppm_no_trp_ML\n+test_one_hybrid\n+tov_carpetevolutionmask\n+tov_carpetevolutionmask2\n+tov_slowsector", "pass_criteria": "all_tests_pass" }
{ "scoring_method": "binary", "resolve_points": 100 }
MSB_einsteintoolkit_Cactus_pr18
multi_swe_bench
Add missing GRHydro_Source.cc in EinsteinEvolve/GRHydro (einsteintoolkit/Cactus#18)
{ "org": "einsteintoolkit", "repo": "Cactus", "pr_number": 18, "issue_title": "Add missing GRHydro_Source.cc in EinsteinEvolve/GRHydro", "issue_body": "This PR adds the missing source file GRHydro_Source.cc to complete the EinsteinEvolve/GRHydro thorn implementation.", "base_commit": "HEAD", "resolved_issues": [ { "number": 18, "title": "Implement the full functionality of GRHydro", "body": "Please implement the full functionality of `GRHydro` by finishing the code in `GRHydro_Source.cc`.\n\n## Thorn Information:\n- Name: GRHydro\n- Target file: GRHydro_Source.cc\n\n## Interface Definition in interface.ccl:\n\n## Schedule Definition in schedule.ccl:\n\n## Parameters Definition in param.ccl:\n\n## Configuration Definition in configuration.ccl:\n\n## Documentation Context in readme.md and doc/documentation.tex\n\n## Related Code Context in src folder\n\n" } ], "commits": [], "diff_url": "", "patch_url": "", "html_url": "", "created_at": "", "merged_at": "" }
{ "env_type": "docker", "docker_image": "mswebench/einsteintoolkit_m_cactus:pr-18", "working_directory": "/testbed", "needs_build": true }
{ "fix_patch": "diff --git a/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_Source.cc b/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_Source.cc\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_Source.cc\n@@ -0,0 +1,709 @@\n+ /*@@\n+ @file GRHydro_Source.cc\n+ @date Nov 29, 2013\n+ @author Christian Reisswig, Joshua Faber, Scott Noble, Bruno Mundim, Ian Hawke\n+ @desc \n+ The geometric source terms for the matter evolution\n+ @enddesc \n+ @@*/\n+\n+\n+\n+\n+#include \"cctk.h\"\n+#include \"cctk_Parameters.h\"\n+#include \"cctk_Arguments.h\"\n+#include \"cctk_Functions.h\"\n+\n+#include <cstring>\n+#include <cassert>\n+\n+#define velx vup\n+#define vely (&vup[N])\n+#define velz (&vup[2*N])\n+#define Bvecx Bprim\n+#define Bvecy (&Bprim[N])\n+#define Bvecz (&Bprim[2*N])\n+#define Avecx Avec\n+#define Avecy (&Avec[N])\n+#define Avecz (&Avec[2*N])\n+#define Avecrhsx Avecrhs\n+#define Avecrhsy (&Avecrhs[N])\n+#define Avecrhsz (&Avecrhs[2*N])\n+#define Bconsx Bcons\n+#define Bconsy (&Bcons[N])\n+#define Bconsz (&Bcons[2*N])\n+#define Bconsrhsx Bconsrhs\n+#define Bconsrhsy (&Bconsrhs[N])\n+#define Bconsrhsz (&Bconsrhs[2*N])\n+\n+\n+extern \"C\" CCTK_INT GRHydro_UseGeneralCoordinates(const cGH * cctkGH);\n+\n+template <typename T> static inline T SQR (T const & x) { return x*x; }\n+\n+\n+struct alldiff2 {\n+ static void apply(const cGH* const restrict cctkGH,\n+ CCTK_REAL dvars[][3],\n+ const CCTK_REAL* const restrict * const restrict vars, \n+ const int i, const int j, const int k,\n+ const CCTK_REAL* restrict const ih,\n+ const int nvars)\n+ {\n+ for (int n=0; n < nvars; ++n) {\n+ dvars[n][0] = (vars[n][CCTK_GFINDEX3D(cctkGH, i+1,j,k)] - vars[n][CCTK_GFINDEX3D(cctkGH, i-1,j,k)]) * 0.5 * ih[0];\n+ dvars[n][1] = (vars[n][CCTK_GFINDEX3D(cctkGH, i,j+1,k)] - vars[n][CCTK_GFINDEX3D(cctkGH, i,j-1,k)]) * 0.5 * ih[1];\n+ dvars[n][2] = (vars[n][CCTK_GFINDEX3D(cctkGH, i,j,k+1)] - vars[n][CCTK_GFINDEX3D(cctkGH, i,j,k-1)]) * 0.5 * ih[2];\n+ }\n+ }\n+};\n+\n+struct alldiff4 {\n+ static void apply(const cGH* const restrict cctkGH,\n+ CCTK_REAL dvars[][3],\n+ const CCTK_REAL* const restrict * const restrict vars, \n+ const int i, const int j, const int k,\n+ const CCTK_REAL* restrict const ih,\n+ const int nvars)\n+ {\n+ for (int n=0; n < nvars; ++n) {\n+ dvars[n][0] = ( vars[n][CCTK_GFINDEX3D(cctkGH, i-2,j,k)] - vars[n][CCTK_GFINDEX3D(cctkGH, i+2,j,k)]\n+ + 8.0 * (vars[n][CCTK_GFINDEX3D(cctkGH, i+1,j,k)] - vars[n][CCTK_GFINDEX3D(cctkGH, i-1,j,k)])) * (1.0 / 12.0) * ih[0];\n+ dvars[n][1] = ( vars[n][CCTK_GFINDEX3D(cctkGH, i,j-2,k)] - vars[n][CCTK_GFINDEX3D(cctkGH, i,j+2,k)]\n+ + 8.0 * (vars[n][CCTK_GFINDEX3D(cctkGH, i,j+1,k)] - vars[n][CCTK_GFINDEX3D(cctkGH, i,j-1,k)])) * (1.0 / 12.0) * ih[1];\n+ dvars[n][2] = ( vars[n][CCTK_GFINDEX3D(cctkGH, i,j,k-2)] - vars[n][CCTK_GFINDEX3D(cctkGH, i,j,k+2)]\n+ + 8.0 * (vars[n][CCTK_GFINDEX3D(cctkGH, i,j,k+1)] - vars[n][CCTK_GFINDEX3D(cctkGH, i,j,k-1)])) * (1.0 / 12.0) * ih[2];\n+ }\n+ }\n+};\n+\n+\n+static inline void UpperMetric(CCTK_REAL& restrict uxx,\n+ CCTK_REAL& restrict uxy,\n+ CCTK_REAL& restrict uxz,\n+ CCTK_REAL& restrict uyy,\n+ CCTK_REAL& restrict uyz,\n+ CCTK_REAL& restrict uzz,\n+ const CCTK_REAL det,\n+ const CCTK_REAL gxx,\n+ const CCTK_REAL gxy,\n+ const CCTK_REAL gxz,\n+ const CCTK_REAL gyy,\n+ const CCTK_REAL gyz,\n+ const CCTK_REAL gzz)\n+{\n+ const CCTK_REAL invdet = 1.0 / det;\n+ uxx = (-gyz*gyz + gyy*gzz)*invdet;\n+ uxy = (gxz*gyz - gxy*gzz)*invdet;\n+ uxz = (-gxz*gyy + gxy*gyz)*invdet;\n+ uyy = (-gxz*gxz + gxx*gzz)*invdet;\n+ uyz = (gxy*gxz - gxx*gyz)*invdet;\n+ uzz = (-gxy*gxy + gxx*gyy)*invdet;\n+\n+ return;\n+}\n+\n+\n+template <class alldiff,\n+ bool do_mhd,\n+ bool do_clean_divergence,\n+ bool do_Avec>\n+static void SourceTerms_LL(CCTK_ARGUMENTS)\n+{\n+ DECLARE_CCTK_ARGUMENTS;\n+ DECLARE_CCTK_PARAMETERS;\n+\n+ /*\n+ Set up multipatch stuff\n+ */\n+\n+ const CCTK_REAL * restrict vup;\n+ const CCTK_REAL * restrict Bprim;\n+ const CCTK_REAL * restrict g11;\n+ const CCTK_REAL * restrict g12;\n+ const CCTK_REAL * restrict g13;\n+ const CCTK_REAL * restrict g22;\n+ const CCTK_REAL * restrict g23;\n+ const CCTK_REAL * restrict g33;\n+ const CCTK_REAL * restrict k11;\n+ const CCTK_REAL * restrict k12;\n+ const CCTK_REAL * restrict k13;\n+ const CCTK_REAL * restrict k22;\n+ const CCTK_REAL * restrict k23;\n+ const CCTK_REAL * restrict k33;\n+ const CCTK_REAL * restrict beta1;\n+ const CCTK_REAL * restrict beta2;\n+ const CCTK_REAL * restrict beta3;\n+\n+ //Multipatch related pointers\n+ if(GRHydro_UseGeneralCoordinates(cctkGH)) {\n+ vup=lvel;\n+ g11=gaa; g12=gab; g13=gac;\n+ g22=gbb; g23=gbc;\n+ g33=gcc;\n+ k11=kaa; k12=kab; k13=kac;\n+ k22=kbb; k23=kbc;\n+ k33=kcc;\n+ Bprim=lBvec;\n+ beta1 = betaa;\n+ beta2 = betab;\n+ beta3 = betac;\n+ } else {\n+ vup=vel;\n+ g11=gxx; g12=gxy; g13=gxz;\n+ g22=gyy; g23=gyz;\n+ g33=gzz;\n+ k11=kxx; k12=kxy; k13=kxz;\n+ k22=kyy; k23=kyz;\n+ k33=kzz;\n+ Bprim=Bvec;\n+ beta1 = betax;\n+ beta2 = betay;\n+ beta3 = betaz;\n+ }\n+\n+ // TODO: for vectorization we might want to use cctk_ash (have to make sure\n+ // sensible values exist everywhere)\n+ const int nx=cctk_lsh[0];\n+ const int ny=cctk_lsh[1];\n+ const int nz=cctk_lsh[2];\n+\n+ const int N = cctk_ash[0]*cctk_ash[1]*cctk_ash[2];\n+\n+ const CCTK_REAL one = 1.00;\n+ const CCTK_REAL two = 2.00;\n+ const CCTK_REAL half = 0.50;\n+ const CCTK_REAL dx = CCTK_DELTA_SPACE(0);\n+ const CCTK_REAL dy = CCTK_DELTA_SPACE(1);\n+ const CCTK_REAL dz = CCTK_DELTA_SPACE(2);\n+ \n+ const CCTK_REAL ih[3] = { 1.0/dx, 1.0/dy, 1.0/dz };\n+\n+#pragma omp parallel for\n+ for (int k=GRHydro_stencil; k < nz-GRHydro_stencil; ++k) {\n+ for (int j=GRHydro_stencil; j < ny-GRHydro_stencil; ++j) {\n+ for (int i=GRHydro_stencil; i < nx-GRHydro_stencil; ++i) {\n+ \n+ const int ijk = CCTK_GFINDEX3D(cctkGH, i, j, k);\n+ \n+ // TODO: these are not needed.\n+ const CCTK_REAL localgxx = g11[ijk];\n+ const CCTK_REAL localgxy = g12[ijk];\n+ const CCTK_REAL localgxz = g13[ijk];\n+ const CCTK_REAL localgyy = g22[ijk];\n+ const CCTK_REAL localgyz = g23[ijk];\n+ const CCTK_REAL localgzz = g33[ijk];\n+\n+ const CCTK_REAL sqrtdet = sdetg[ijk];\n+ const CCTK_REAL invsqrtdet = 1./sqrtdet;\n+ \n+ CCTK_REAL uxx, uxy, uxz, uyy, uyz, uzz;\n+ UpperMetric(uxx, uxy, uxz, uyy, uyz, uzz, sqrtdet*sqrtdet, localgxx,\n+ localgxy, localgxz, localgyy, localgyz, localgzz);\n+ \n+ const CCTK_REAL shiftx = beta1[ijk];\n+ const CCTK_REAL shifty = beta2[ijk];\n+ const CCTK_REAL shiftz = beta3[ijk];\n+\n+ // Derivatives of the lapse, metric and shift\n+\n+ const int nvars = 10;\n+ const CCTK_REAL* const restrict vars[nvars] = { beta1, beta2, beta3, alp,\n+ g11, g12, g13,\n+ g22, g23,\n+ g33 };\n+ CCTK_REAL dvars[nvars][3];\n+ \n+ alldiff::apply(cctkGH, dvars, vars, i, j, k, ih, nvars);\n+ \n+ const CCTK_REAL dx_betax = dvars[0][0];\n+ const CCTK_REAL dx_betay = dvars[1][0];\n+ const CCTK_REAL dx_betaz = dvars[2][0];\n+ \n+ const CCTK_REAL dy_betax = dvars[0][1];\n+ const CCTK_REAL dy_betay = dvars[1][1];\n+ const CCTK_REAL dy_betaz = dvars[2][1];\n+ \n+ const CCTK_REAL dz_betax = dvars[0][2];\n+ const CCTK_REAL dz_betay = dvars[1][2];\n+ const CCTK_REAL dz_betaz = dvars[2][2];\n+ \n+ const CCTK_REAL dx_alp = dvars[3][0];\n+ const CCTK_REAL dy_alp = dvars[3][1];\n+ const CCTK_REAL dz_alp = dvars[3][2];\n+\n+ const CCTK_REAL dx_gxx = dvars[4][0];\n+ const CCTK_REAL dx_gxy = dvars[5][0];\n+ const CCTK_REAL dx_gxz = dvars[6][0];\n+ const CCTK_REAL dx_gyy = dvars[7][0];\n+ const CCTK_REAL dx_gyz = dvars[8][0];\n+ const CCTK_REAL dx_gzz = dvars[9][0];\n+ const CCTK_REAL dy_gxx = dvars[4][1];\n+ const CCTK_REAL dy_gxy = dvars[5][1];\n+ const CCTK_REAL dy_gxz = dvars[6][1];\n+ const CCTK_REAL dy_gyy = dvars[7][1];\n+ const CCTK_REAL dy_gyz = dvars[8][1];\n+ const CCTK_REAL dy_gzz = dvars[9][1];\n+ const CCTK_REAL dz_gxx = dvars[4][2];\n+ const CCTK_REAL dz_gxy = dvars[5][2];\n+ const CCTK_REAL dz_gxz = dvars[6][2];\n+ const CCTK_REAL dz_gyy = dvars[7][2];\n+ const CCTK_REAL dz_gyz = dvars[8][2];\n+ const CCTK_REAL dz_gzz = dvars[9][2];\n+\n+\n+ const CCTK_REAL invalp = 1.0 / alp[ijk];\n+ const CCTK_REAL invalp2 = SQR(invalp);\n+ const CCTK_REAL velxshift = velx[ijk] - shiftx*invalp;\n+ const CCTK_REAL velyshift = vely[ijk] - shifty*invalp;\n+ const CCTK_REAL velzshift = velz[ijk] - shiftz*invalp;\n+\n+ // vel_i = g_ij v^j\n+ // B_i = g_ij B^i\n+\n+ const CCTK_REAL vlowx = g11[ijk]*velx[ijk] + g12[ijk]*vely[ijk] + g13[ijk]*velz[ijk];\n+ const CCTK_REAL vlowy = g12[ijk]*velx[ijk] + g22[ijk]*vely[ijk] + g23[ijk]*velz[ijk];\n+ const CCTK_REAL vlowz = g13[ijk]*velx[ijk] + g23[ijk]*vely[ijk] + g33[ijk]*velz[ijk];\n+ const CCTK_REAL Bvecxlow = do_mhd ? g11[ijk]*Bvecx[ijk] + g12[ijk]*Bvecy[ijk] + g13[ijk]*Bvecz[ijk] : 0;\n+ const CCTK_REAL Bvecylow = do_mhd ? g12[ijk]*Bvecx[ijk] + g22[ijk]*Bvecy[ijk] + g23[ijk]*Bvecz[ijk] : 0;\n+ const CCTK_REAL Bveczlow = do_mhd ? g13[ijk]*Bvecx[ijk] + g23[ijk]*Bvecy[ijk] + g33[ijk]*Bvecz[ijk] : 0;\n+\n+ // B^i v_i (= b^0/u^0)\n+ const CCTK_REAL Bdotv = do_mhd ? vlowx*Bvecx[ijk]+vlowy*Bvecy[ijk]+vlowz*Bvecz[ijk] : 0;\n+\n+ // v^2 = v_i v^i; w=(1-v^2)^{-1/2}\n+\n+ const CCTK_REAL v2 = vlowx*velx[ijk] + vlowy*vely[ijk] + vlowz*velz[ijk];\n+ const CCTK_REAL invw = sqrt(1.0-v2);\n+ const CCTK_REAL w = 1./invw;\n+\n+ // b^2 = B^i B_i / w^2 + (b^0/u^0)^2\n+\n+ const CCTK_REAL b2 = do_mhd ? (Bvecx[ijk]*Bvecxlow+Bvecy[ijk]*Bvecylow+Bvecz[ijk]*Bveczlow)*SQR(invw)+SQR(Bdotv) : 0;\n+\n+ // b_i = B_i/w +w*(B dot v)*v_i\n+ const CCTK_REAL bxlow = do_mhd ? Bvecxlow*invw+w*Bdotv*vlowx : 0;\n+ const CCTK_REAL bylow = do_mhd ? Bvecylow*invw+w*Bdotv*vlowy : 0;\n+ const CCTK_REAL bzlow = do_mhd ? Bveczlow*invw+w*Bdotv*vlowz : 0;\n+\n+\n+ // These are the contravariant components\n+ const CCTK_REAL bt = do_mhd ? w*invalp*Bdotv : 0;\n+ const CCTK_REAL bx = do_mhd ? Bvecx[ijk]*invw+w*Bdotv*velxshift : 0;\n+ const CCTK_REAL by = do_mhd ? Bvecy[ijk]*invw+w*Bdotv*velyshift : 0;\n+ const CCTK_REAL bz = do_mhd ? Bvecz[ijk]*invw+w*Bdotv*velzshift : 0;\n+\n+ // TODO: all of these can be expressed much more easily in terms of the\n+ // conservatives\n+ const CCTK_REAL rhohstarW2 = (rho[ijk]*(one + eps[ijk]) + (press[ijk] + b2)) *\n+ SQR(w);\n+ const CCTK_REAL pstar = press[ijk]+0.50*b2;\n+\n+ // For a change, these are T^{ij}\n+\n+ // TODO: strict IEEE compliance does not let the compiler remove \"+ 0\"\n+ // terms, so we have to do something else here\n+ const CCTK_REAL t00 = (rhohstarW2 - pstar)*invalp2-SQR(bt);\n+ const CCTK_REAL t0x = rhohstarW2*velxshift*invalp +\n+ pstar*shiftx*invalp2-bt*bx;\n+ const CCTK_REAL t0y = rhohstarW2*velyshift*invalp +\n+ pstar*shifty*invalp2-bt*by;\n+ const CCTK_REAL t0z = rhohstarW2*velzshift*invalp +\n+ pstar*shiftz*invalp2-bt*bz;\n+ const CCTK_REAL txx = rhohstarW2*velxshift*velxshift +\n+ pstar*(uxx - shiftx*shiftx*invalp2)-SQR(bx);\n+ const CCTK_REAL txy = rhohstarW2*velxshift*velyshift +\n+ pstar*(uxy - shiftx*shifty*invalp2)-bx*by;\n+ const CCTK_REAL txz = rhohstarW2*velxshift*velzshift +\n+ pstar*(uxz - shiftx*shiftz*invalp2)-bx*bz;\n+ const CCTK_REAL tyy = rhohstarW2*velyshift*velyshift +\n+ pstar*(uyy - shifty*shifty*invalp2)-SQR(by);\n+ const CCTK_REAL tyz = rhohstarW2*velyshift*velzshift +\n+ pstar*(uyz - shifty*shiftz*invalp2)-by*bz;\n+ const CCTK_REAL tzz = rhohstarW2*velzshift*velzshift +\n+ pstar*(uzz - shiftz*shiftz*invalp2)-SQR(bz);\n+\n+// Contract the shift with the extrinsic curvature\n+\n+ const CCTK_REAL shiftshiftk = shiftx*shiftx*k11[ijk] +\n+ shifty*shifty*k22[ijk] +\n+ shiftz*shiftz*k33[ijk] +\n+ two*(shiftx*shifty*k12[ijk] +\n+ shiftx*shiftz*k13[ijk] +\n+ shifty*shiftz*k23[ijk]);\n+\n+ const CCTK_REAL shiftkx = shiftx*k11[ijk] + shifty*k12[ijk] + shiftz*k13[ijk];\n+ const CCTK_REAL shiftky = shiftx*k12[ijk] + shifty*k22[ijk] + shiftz*k23[ijk];\n+ const CCTK_REAL shiftkz = shiftx*k13[ijk] + shifty*k23[ijk] + shiftz*k33[ijk];\n+\n+// Contract the matter terms with the extrinsic curvature\n+\n+ const CCTK_REAL sumTK = txx*k11[ijk] + tyy*k22[ijk] + tzz*k33[ijk]\n+ + two*(txy*k12[ijk] + txz*k13[ijk] + tyz*k23[ijk]);\n+\n+// Update term for tau\n+ \n+ const CCTK_REAL tau_source = t00*\n+ (shiftshiftk - (shiftx*dx_alp + shifty*dy_alp + shiftz*dz_alp) )\n+ + t0x*(-dx_alp + two*shiftkx)\n+ + t0y*(-dy_alp + two*shiftky)\n+ + t0z*(-dz_alp + two*shiftkz)\n+ + sumTK;\n+\n+// The following looks very little like the terms in the\n+// standard papers. Take a look in the ThornGuide to see why\n+// it is really the same thing.\n+\n+// Contract the shift with derivatives of the metric\n+\n+ const CCTK_REAL halfshiftdgx = half*(shiftx*shiftx*dx_gxx +\n+ shifty*shifty*dx_gyy + shiftz*shiftz*dx_gzz) +\n+ shiftx*shifty*dx_gxy + shiftx*shiftz*dx_gxz +\n+ shifty*shiftz*dx_gyz;\n+ const CCTK_REAL halfshiftdgy = half*(shiftx*shiftx*dy_gxx +\n+ shifty*shifty*dy_gyy + shiftz*shiftz*dy_gzz) +\n+ shiftx*shifty*dy_gxy + shiftx*shiftz*dy_gxz +\n+ shifty*shiftz*dy_gyz;\n+ const CCTK_REAL halfshiftdgz = half*(shiftx*shiftx*dz_gxx +\n+ shifty*shifty*dz_gyy + shiftz*shiftz*dz_gzz) +\n+ shiftx*shifty*dz_gxy + shiftx*shiftz*dz_gxz +\n+ shifty*shiftz*dz_gyz;\n+\n+// Contract the matter with derivatives of the metric\n+\n+ const CCTK_REAL halfTdgx = half*(txx*dx_gxx + tyy*dx_gyy + tzz*dx_gzz) +\n+ txy*dx_gxy + txz*dx_gxz + tyz*dx_gyz;\n+ const CCTK_REAL halfTdgy = half*(txx*dy_gxx + tyy*dy_gyy + tzz*dy_gzz) +\n+ txy*dy_gxy + txz*dy_gxz + tyz*dy_gyz;\n+ const CCTK_REAL halfTdgz = half*(txx*dz_gxx + tyy*dz_gyy + tzz*dz_gzz) +\n+ txy*dz_gxy + txz*dz_gxz + tyz*dz_gyz;\n+\n+ \n+ const CCTK_REAL sx_source = t00*\n+ (halfshiftdgx - alp[ijk]*dx_alp) + halfTdgx +\n+ t0x*(shiftx*dx_gxx + shifty*dx_gxy + shiftz*dx_gxz) +\n+ t0y*(shiftx*dx_gxy + shifty*dx_gyy + shiftz*dx_gyz) +\n+ t0z*(shiftx*dx_gxz + shifty*dx_gyz + shiftz*dx_gzz) +\n+ rhohstarW2*invalp*(vlowx*dx_betax + vlowy*dx_betay + vlowz*dx_betaz) -\n+ bt*(bxlow*dx_betax + bylow*dx_betay + bzlow*dx_betaz);\n+ \n+ const CCTK_REAL sy_source = t00*\n+ (halfshiftdgy - alp[ijk]*dy_alp) + halfTdgy +\n+ t0x*(shiftx*dy_gxx + shifty*dy_gxy + shiftz*dy_gxz) +\n+ t0y*(shiftx*dy_gxy + shifty*dy_gyy + shiftz*dy_gyz) +\n+ t0z*(shiftx*dy_gxz + shifty*dy_gyz + shiftz*dy_gzz) +\n+ rhohstarW2*invalp*(vlowx*dy_betax + vlowy*dy_betay + vlowz*dy_betaz) -\n+ bt*(bxlow*dy_betax + bylow*dy_betay + bzlow*dy_betaz);\n+\n+ const CCTK_REAL sz_source = t00*\n+ (halfshiftdgz - alp[ijk]*dz_alp) + halfTdgz +\n+ t0x*(shiftx*dz_gxx + shifty*dz_gxy + shiftz*dz_gxz) +\n+ t0y*(shiftx*dz_gxy + shifty*dz_gyy + shiftz*dz_gyz) +\n+ t0z*(shiftx*dz_gxz + shifty*dz_gyz + shiftz*dz_gzz) +\n+ rhohstarW2*invalp*(vlowx*dz_betax + vlowy*dz_betay + vlowz*dz_betaz) -\n+ bt*(bxlow*dz_betax + bylow*dz_betay + bzlow*dz_betaz);\n+\n+ densrhs[ijk] = 0.0;\n+ srhs[ijk] = alp[ijk]*sqrtdet*sx_source;\n+ srhs[ijk + N] = alp[ijk]*sqrtdet*sy_source;\n+ srhs[ijk + 2*N] = alp[ijk]*sqrtdet*sz_source;\n+ taurhs[ijk] = alp[ijk]*sqrtdet*tau_source;\n+\n+ if (do_Avec) {\n+\n+ // B^i and A^i both live in cell centers currently\n+ const CCTK_REAL Avcx_source = alp[ijk]*sqrtdet*(velyshift*Bvecz[ijk] - velzshift*Bvecy[ijk]);\n+ const CCTK_REAL Avcy_source = alp[ijk]*sqrtdet*(velzshift*Bvecx[ijk] - velxshift*Bvecz[ijk]);\n+ const CCTK_REAL Avcz_source = alp[ijk]*sqrtdet*(velxshift*Bvecy[ijk] - velyshift*Bvecx[ijk]);\n+\n+ Avecrhsx[ijk] = Avcx_source;\n+ Avecrhsy[ijk] = Avcy_source;\n+ Avecrhsz[ijk] = Avcz_source;\n+\n+ }\n+\n+ if(do_clean_divergence) {\n+ \n+ // g^{jk} d_i g_{kj} = d_i (g) / det\n+ const CCTK_REAL dx_det_bydet = uxx*dx_gxx + uyy*dx_gyy + uzz*dx_gzz +\n+ two*(uxy*dx_gxy+uxz*dx_gxz+uyz*dx_gyz);\n+ const CCTK_REAL dy_det_bydet = uxx*dy_gxx + uyy*dy_gyy + uzz*dy_gzz +\n+ two*(uxy*dy_gxy+uxz*dy_gxz+uyz*dy_gyz);\n+ const CCTK_REAL dz_det_bydet = uxx*dz_gxx + uyy*dz_gyy + uzz*dz_gzz +\n+ two*(uxy*dz_gxy+uxz*dz_gxz+uyz*dz_gyz);\n+\n+ // g^{ik} d_k g_{li}\n+ const CCTK_REAL gdg_x = uxx*dx_gxx + uxy*dy_gxx + uxz*dz_gxx +\n+ uxy*dx_gxy + uyy*dy_gxy + uyz*dz_gxy +\n+ uxz*dx_gxz + uyz*dy_gxz + uzz*dz_gxz;\n+\n+ const CCTK_REAL gdg_y = uxx*dx_gxy + uxy*dy_gxy + uxz*dz_gxy +\n+ uxy*dx_gyy + uyy*dy_gyy + uyz*dz_gyy +\n+ uxz*dx_gyz + uyz*dy_gyz + uzz*dz_gyz;\n+\n+ const CCTK_REAL gdg_z = uxx*dx_gxz + uxy*dy_gxz + uxz*dz_gxz +\n+ uxy*dx_gyz + uyy*dy_gyz + uyz*dz_gyz +\n+ uxz*dx_gzz + uyz*dy_gzz + uzz*dz_gzz;\n+\n+ CCTK_REAL bvcx_source, bvcy_source, bvcz_source;\n+ psidcrhs[ijk] = -one * (kap_dc*alp[ijk] + \n+ dx_betax + dy_betay + dz_betaz ) * psidc[ijk] + \n+ Bconsx[ijk] * (dx_alp - half*alp[ijk] * \n+ ( uxx*dx_gxx + uyy*dx_gyy + uzz*dx_gzz + two*uxy*dx_gxy + \n+ two*uxz*dx_gxz + two*uyz*dx_gyz ) )*invsqrtdet + \n+ Bconsy[ijk] * (dy_alp - half*alp[ijk] * \n+ ( uxx*dy_gxx + uyy*dy_gyy + uzz*dy_gzz + two*uxy*dy_gxy + \n+ two*uxz*dy_gxz + two*uyz*dy_gyz ) )*invsqrtdet + \n+ Bconsz[ijk] * (dz_alp - half*alp[ijk] * \n+ ( uxx*dz_gxx + uyy*dz_gyy + uzz*dz_gzz + two*uxy*dz_gxy + \n+ two*uxz*dz_gxz + two*uyz*dz_gyz ) )*invsqrtdet;\n+\n+ bvcx_source = -one * ( Bconsx[ijk]*dx_betax + \n+ Bconsy[ijk]*dy_betax + Bconsz[ijk]*dz_betax ) + \n+ psidc[ijk]*sqrtdet*(( uxx*dx_alp+uxy*dy_alp+uxz*dz_alp ) + \n+ alp[ijk]*(half*( uxx*dx_det_bydet + \n+ uxy*dy_det_bydet + uxz*dz_det_bydet) - \n+ ( uxx*gdg_x + uxy*gdg_y + uxz*gdg_z )));\n+\n+ bvcy_source = -one * ( Bconsx[ijk]*dx_betay + \n+ Bconsy[ijk]*dy_betay + Bconsz[ijk]*dz_betay ) + \n+ psidc[ijk]*sqrtdet*(( uxy*dx_alp+uyy*dy_alp+uyz*dz_alp ) + \n+ alp[ijk]*(half*( uxy*dx_det_bydet + \n+ uyy*dy_det_bydet + uyz*dz_det_bydet ) - \n+ ( uxy*gdg_x + uyy*gdg_y + uyz*gdg_z )));\n+\n+ bvcz_source = -one * ( Bconsx[ijk]*dx_betaz + \n+ Bconsy[ijk]*dy_betaz + Bconsz[ijk]*dz_betaz ) + \n+ psidc[ijk]*sqrtdet*(( uxz*dx_alp+uyz*dy_alp+uzz*dz_alp ) + \n+ alp[ijk]*(half*( uxz*dx_det_bydet + \n+ uyz*dy_det_bydet + uzz*dz_det_bydet ) - \n+ ( uxz*gdg_x + uyz*gdg_y + uzz*gdg_z )));\n+\n+ Bconsrhsx[ijk] = bvcx_source;\n+ Bconsrhsy[ijk] = bvcy_source;\n+ Bconsrhsz[ijk] = bvcz_source;\n+ } // if(do_clean_divergence)\n+\n+ } // for(i\n+ } // for(j\n+ } // for(k\n+\n+#if(0) // poison edges of domain\n+ static int last_iteration_seen = -1;\n+ static int reflevel = -1;\n+ static int mol_substep;\n+ if(last_iteration_seen != cctk_iteration || reflevel != *GRHydro_reflevel) {\n+ last_iteration_seen = cctk_iteration;\n+ reflevel = *GRHydro_reflevel;\n+ mol_substep = 0;\n+ } else {\n+ mol_substep += 1;\n+ }\n+ for(k = 0 ; k < GRHydro_stencil*mol_substep ; ++k) {\n+ for(j = 0 ; j < cctk_ash[1] ; ++j) {\n+ for(i = 0 ; i < cctk_ash[0] ; ++i) {\n+ dens[CCTK_GFINDEX3D(i,j,k)] = -1e100\n+ Scon[CCTK_VECTGFINDEX3D(i,j,k,0)] = -1e100\n+ Scon[CCTK_VECTGFINDEX3D(i,j,k,1)] = -1e100\n+ Scon[CCTK_VECTGFINDEX3D(i,j,k,2)] = -1e100\n+ tau[CCTK_GFINDEX3D(i,j,k)] = -1e100\n+ if(do_mhd) {\n+ Bcons[CCTK_VECTGFINDEX3D(i,j,k,0)] = -1e100\n+ Bcons[CCTK_VECTGFINDEX3D(i,j,k,1)] = -1e100\n+ Bcons[CCTK_VECTGFINDEX3D(i,j,k,2)] = -1e100\n+ }\n+ if(do_clean_divergene)\n+ psidc[CCTK_GFINDEX3D(i,j,k)] = -1e100\n+ }\n+ }\n+ }\n+ for(k = cctk_ash[2]-GRHydro_stencil*mol_substep ; k < cctk_ash[2] ; ++k) {\n+ for(j = 0 ; j < cctk_ash[1] ; ++j) {\n+ for(i = 0 ; i < cctk_ash[0] ; ++i) {\n+ dens[CCTK_GFINDEX3D(i,j,k)] = -1e100\n+ Scon[CCTK_VECTGFINDEX3D(i,j,k,0)] = -1e100\n+ Scon[CCTK_VECTGFINDEX3D(i,j,k,1)] = -1e100\n+ Scon[CCTK_VECTGFINDEX3D(i,j,k,2)] = -1e100\n+ tau[CCTK_GFINDEX3D(i,j,k)] = -1e100\n+ if(do_mhd) {\n+ Bcons[CCTK_VECTGFINDEX3D(i,j,k,0)] = -1e100\n+ Bcons[CCTK_VECTGFINDEX3D(i,j,k,1)] = -1e100\n+ Bcons[CCTK_VECTGFINDEX3D(i,j,k,2)] = -1e100\n+ }\n+ if(do_clean_divergene)\n+ psidc[CCTK_GFINDEX3D(i,j,k)] = -1e100\n+ }\n+ }\n+ }\n+ for(i = 0 ; i < GRHydro_stencil*mol_substep ; ++i) {\n+ for(k = 0 ; k < cctk_ash[2] ; ++k) {\n+ for(j = 0 ; j < cctk_ash[1] ; ++j) {\n+ dens[CCTK_GFINDEX3D(i,j,k)] = -1e100\n+ Scon[CCTK_VECTGFINDEX3D(i,j,k,0)] = -1e100\n+ Scon[CCTK_VECTGFINDEX3D(i,j,k,1)] = -1e100\n+ Scon[CCTK_VECTGFINDEX3D(i,j,k,2)] = -1e100\n+ tau[CCTK_GFINDEX3D(i,j,k)] = -1e100\n+ if(do_mhd) {\n+ Bcons[CCTK_VECTGFINDEX3D(i,j,k,0)] = -1e100\n+ Bcons[CCTK_VECTGFINDEX3D(i,j,k,1)] = -1e100\n+ Bcons[CCTK_VECTGFINDEX3D(i,j,k,2)] = -1e100\n+ }\n+ if(do_clean_divergene)\n+ psidc[CCTK_GFINDEX3D(i,j,k)] = -1e100\n+ }\n+ }\n+ }\n+ for(i = cctk_ash[0]-GRHydro_stencil*mol_substep ; i < cctk_ash[0] ; ++i) {\n+ for(k = 0 ; k < cctk_ash[2] ; ++k) {\n+ for(j = 0 ; j < cctk_ash[1] ; ++j) {\n+ dens[CCTK_GFINDEX3D(i,j,k)] = -1e100\n+ Scon[CCTK_VECTGFINDEX3D(i,j,k,0)] = -1e100\n+ Scon[CCTK_VECTGFINDEX3D(i,j,k,1)] = -1e100\n+ Scon[CCTK_VECTGFINDEX3D(i,j,k,2)] = -1e100\n+ tau[CCTK_GFINDEX3D(i,j,k)] = -1e100\n+ if(do_mhd) {\n+ Bcons[CCTK_VECTGFINDEX3D(i,j,k,0)] = -1e100\n+ Bcons[CCTK_VECTGFINDEX3D(i,j,k,1)] = -1e100\n+ Bcons[CCTK_VECTGFINDEX3D(i,j,k,2)] = -1e100\n+ }\n+ if(do_clean_divergene)\n+ psidc[CCTK_GFINDEX3D(i,j,k)] = -1e100\n+ }\n+ }\n+ }\n+ for(j = 0 ; j < GRHydro_stencil*mol_substep ; ++j) {\n+ for(i = 0 ; i < cctk_ash[0] ; ++i) {\n+ for(k = 0 ; k < cctk_ash[2] ; ++k) {\n+ dens[CCTK_GFINDEX3D(i,j,k)] = -1e100\n+ Scon[CCTK_VECTGFINDEX3D(i,j,k,0)] = -1e100\n+ Scon[CCTK_VECTGFINDEX3D(i,j,k,1)] = -1e100\n+ Scon[CCTK_VECTGFINDEX3D(i,j,k,2)] = -1e100\n+ tau[CCTK_GFINDEX3D(i,j,k)] = -1e100\n+ if(do_mhd) {\n+ Bcons[CCTK_VECTGFINDEX3D(i,j,k,0)] = -1e100\n+ Bcons[CCTK_VECTGFINDEX3D(i,j,k,1)] = -1e100\n+ Bcons[CCTK_VECTGFINDEX3D(i,j,k,2)] = -1e100\n+ }\n+ if(do_clean_divergene)\n+ psidc[CCTK_GFINDEX3D(i,j,k)] = -1e100\n+ }\n+ }\n+ }\n+ for(j = cctk_ash[1]-GRHydro_stencil*mol_substep ; j < cctk_ash[1] ; ++j) {\n+ for(i = 0 ; i < cctk_ash[0] ; ++i) {\n+ for(k = 0 ; k < cctk_ash[2] ; ++k) {\n+ dens[CCTK_GFINDEX3D(i,j,k)] = -1e100\n+ Scon[CCTK_VECTGFINDEX3D(i,j,k,0)] = -1e100\n+ Scon[CCTK_VECTGFINDEX3D(i,j,k,1)] = -1e100\n+ Scon[CCTK_VECTGFINDEX3D(i,j,k,2)] = -1e100\n+ tau[CCTK_GFINDEX3D(i,j,k)] = -1e100\n+ if(do_mhd) {\n+ Bcons[CCTK_VECTGFINDEX3D(i,j,k,0)] = -1e100\n+ Bcons[CCTK_VECTGFINDEX3D(i,j,k,1)] = -1e100\n+ Bcons[CCTK_VECTGFINDEX3D(i,j,k,2)] = -1e100\n+ }\n+ if(do_clean_divergene)\n+ psidc[CCTK_GFINDEX3D(i,j,k)] = -1e100\n+ }\n+ }\n+ }\n+#endif\n+}\n+\n+extern \"C\" void SourceTerms(CCTK_ARGUMENTS)\n+{\n+ DECLARE_CCTK_ARGUMENTS;\n+ DECLARE_CCTK_PARAMETERS;\n+\n+ void (*sources)(CCTK_ARGUMENTS) = NULL;\n+ const bool do_Avec = CCTK_EQUALS(Bvec_evolution_method, \"GRHydro_Avec\");\n+#define T(e,t) (!!(e)==(t))\n+#define T3(t1,t2,t3) \\\n+ (T(*evolve_MHD,t1) && \\\n+ T(clean_divergence,t2) && \\\n+ T(do_Avec,t3))\n+#define SET_SOURCES(df,t1,t2,t3) \\\n+ if(T3(t1,t2,t3)) \\\n+ sources=SourceTerms_LL<df,t1,t2,t3>;\n+ enum do_t {noMHD=0,MHD=1,noDC=0,DC=1,noAVec=0,AVec=1};\n+\n+ // order of arguments:\n+ // do_MHD do_clean_divergence do_Avec\n+ if(sources_spatial_order == 4) {\n+ // no MHD\n+ SET_SOURCES(alldiff4,noMHD,noDC,noAVec)\n+\n+ // not all combinations make sense for MHD, we list the ones that do\n+ SET_SOURCES(alldiff4, MHD,noDC,noAVec)\n+ SET_SOURCES(alldiff4, MHD, DC,noAVec)\n+ SET_SOURCES(alldiff4, MHD, DC,noAVec)\n+ SET_SOURCES(alldiff4, MHD,noDC, AVec)\n+ } else if(sources_spatial_order == 2) {\n+ // no MHD\n+ SET_SOURCES(alldiff2,noMHD,noDC,noAVec)\n+\n+ // not all combinations make sense for MHD, we list the ones that do\n+ SET_SOURCES(alldiff2, MHD,noDC,noAVec)\n+ SET_SOURCES(alldiff2, MHD, DC,noAVec)\n+ SET_SOURCES(alldiff2, MHD, DC,noAVec)\n+ SET_SOURCES(alldiff2, MHD,noDC, AVec)\n+ }\n+\n+ if(sources == NULL) {\n+ CCTK_VError(__LINE__, __FILE__, CCTK_THORNSTRING, \n+ \"No source terms can be computed for combination \"\n+ \"do_mhd = %d \"\n+ \"do_clean_divergence = %d \"\n+ \"do_Avec = %d sources_spatial_order = %d\",\n+ int(*evolve_MHD),\n+ int(clean_divergence),\n+ int(do_Avec), int(sources_spatial_order));\n+ }\n+\n+ // do some non-time critial operations here to reduce the number of templates \n+ if(transport_constraints) {\n+ const int N = cctk_ash[0]*cctk_ash[1]*cctk_ash[2];\n+ // not much need to OpenMP parallelize this since it is pure memory access\n+ // and memset is highly optimized\n+ memset(Evec, 0, sizeof(Evec[0])*3*N);\n+ // I think IEEE requires an all zero byte double to be 0.\n+ assert(Evec[0] == 0.);\n+ }\n+ if(*evolve_Y_e) {\n+ const int N = cctk_ash[0]*cctk_ash[1]*cctk_ash[2];\n+ // not much need to OpenMP parallelize this since it is pure memory access\n+ // and memset is highly optimized\n+ memset(Y_e_con_rhs, 0, sizeof(Y_e_con_rhs[0])*N);\n+ // I think IEEE requires an all zero byte double to be 0.\n+ assert(Y_e_con_rhs[0] == 0.);\n+ }\n+ if(number_of_tracers>0) {\n+ const int N = cctk_ash[0]*cctk_ash[1]*cctk_ash[2];\n+ // not much need to OpenMP parallelize this since it is pure memory access\n+ // and memset is highly optimized\n+ memset(cons_tracerrhs, 0, sizeof(cons_tracerrhs[0])*number_of_tracers*N);\n+ // I think IEEE requires an all zero byte double to be 0.\n+ assert(cons_tracerrhs[0] == 0.);\n+ }\n+ if(*evolve_entropy) {\n+ const int N = cctk_ash[0]*cctk_ash[1]*cctk_ash[2];\n+ // not much need to OpenMP parallelize this since it is pure memory access\n+ // and memset is highly optimized\n+ memset(entropyrhs, 0, sizeof(entropyrhs[0])*N);\n+ // I think IEEE requires an all zero byte double to be 0.\n+ assert(entropyrhs[0] == 0.);\n+ }\n+ if(track_divB) {\n+ const int N = cctk_ash[0]*cctk_ash[1]*cctk_ash[2];\n+ // not much need to OpenMP parallelize this since it is pure memory access\n+ // and memset is highly optimized\n+ memset(divB, 0, sizeof(divB[0])*N);\n+ // I think IEEE requires an all zero byte double to be 0.\n+ assert(divB[0] == 0.);\n+ }\n+\n+ sources(CCTK_PASS_CTOC);\n+}\n+\n+" }
{ "test_patch": "diff --git a/all_tests.txt b/all_tests.txt\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/all_tests.txt\n@@ -0,0 +1,10 @@\n+GRHydro_test_shock\n+GRHydro_test_shock_mp5\n+GRHydro_test_shock_ppm\n+GRHydro_test_tov_ppm_ML\n+GRHydro_test_tov_ppm_ML_disable_internal_excision\n+GRHydro_test_tov_ppm_no_trp_ML\n+test_one_hybrid\n+tov_carpetevolutionmask\n+tov_carpetevolutionmask2\n+tov_slowsector", "pass_criteria": "all_tests_pass" }
{ "scoring_method": "binary", "resolve_points": 100 }
MSB_einsteintoolkit_Cactus_pr19
multi_swe_bench
Add missing GRHydro_RiemannSolveAM.F90 in EinsteinEvolve/GRHydro (einsteintoolkit/Cactus#19)
{ "org": "einsteintoolkit", "repo": "Cactus", "pr_number": 19, "issue_title": "Add missing GRHydro_RiemannSolveAM.F90 in EinsteinEvolve/GRHydro", "issue_body": "This PR adds the missing source file GRHydro_RiemannSolveAM.F90 to complete the EinsteinEvolve/GRHydro thorn implementation.", "base_commit": "HEAD", "resolved_issues": [ { "number": 19, "title": "Implement the full functionality of GRHydro", "body": "Please implement the full functionality of `GRHydro` by finishing the code in `GRHydro_RiemannSolveAM.F90`.\n\n## Thorn Information:\n- Name: GRHydro\n- Target file: GRHydro_RiemannSolveAM.F90\n\n## Interface Definition in interface.ccl:\n\n## Schedule Definition in schedule.ccl:\n\n## Parameters Definition in param.ccl:\n\n## Configuration Definition in configuration.ccl:\n\n## Documentation Context in readme.md and doc/documentation.tex\n\n## Related Code Context in src folder\n\n" } ], "commits": [], "diff_url": "", "patch_url": "", "html_url": "", "created_at": "", "merged_at": "" }
{ "env_type": "docker", "docker_image": "mswebench/einsteintoolkit_m_cactus:pr-19", "working_directory": "/testbed", "needs_build": true }
{ "fix_patch": "diff --git a/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_RiemannSolveAM.F90 b/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_RiemannSolveAM.F90\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/arrangements/EinsteinEvolve/GRHydro/src/GRHydro_RiemannSolveAM.F90\n@@ -0,0 +1,142 @@\n+ /*@@\n+ @file GRHydro_RiemannSolveAM.F90\n+ @date Sep 1, 2010\n+ @author \n+ @desc \n+ A wrapper routine to call the correct Riemann solver\n+ @enddesc \n+ @@*/\n+\n+#include \"cctk.h\"\n+#include \"cctk_Parameters.h\"\n+#include \"cctk_Arguments.h\"\n+#include \"cctk_Functions.h\"\n+#include \"GRHydro_Macros.h\"\n+\n+ /*@@\n+ @routine RiemannSolveAM\n+ @date Sep 1, 2010\n+ @author Joshua Faber, Scott Noble, Bruno Mundim, Pedro Montero, Ian Hawke\n+ @desc \n+ A wrapper routine to switch between the different Riemann solvers.\n+ @enddesc \n+ @calls \n+ @calledby \n+ @history \n+ \n+ @endhistory \n+\n+@@*/\n+\n+subroutine RiemannSolveAM(CCTK_ARGUMENTS)\n+\n+ implicit none\n+ \n+ DECLARE_CCTK_ARGUMENTS\n+ DECLARE_CCTK_PARAMETERS\n+ DECLARE_CCTK_FUNCTIONS\n+\n+ if (CCTK_EQUALS(riemann_solver,\"HLLE\").or.CCTK_EQUALS(riemann_solver,\"LLF\")) then\n+ \n+ call GRHydro_HLLE_AM(CCTK_PASS_FTOF)\n+ \n+ if (evolve_tracer .ne. 0) then\n+ \n+!!$ There are no special calls for tracers, which care not one whit about B-fields! \n+!!$ Just call the standard version...\n+ \n+ call GRHydro_HLLE_Tracer(CCTK_PASS_FTOF)\n+ \n+ end if\n+ \n+!!$ else if (CCTK_EQUALS(riemann_solver,\"Roe\")) then \n+!!$ \n+!!$ call GRHydro_RoeSolveAM(CCTK_PASS_FTOF)\n+!!$\n+!!$ if (evolve_tracer .ne. 0) then\n+!!$ \n+!!$ call GRHydro_HLLE_Tracer(CCTK_PASS_FTOF)\n+!!$\n+!!$ end if\n+!!$ \n+!!$ else if (CCTK_EQUALS(riemann_solver,\"Marquina\")) then \n+!!$ \n+!!$ call GRHydro_MarquinaM(CCTK_PASS_FTOF)\n+ \n+!!$ Tracers are built directly in to the Marquina solver\n+ \n+ else\n+ \n+ call CCTK_ERROR(\"Roe and Marquina not implemented in MHD yet!!!\")\n+ STOP\n+ \n+ end if\n+ \n+end subroutine RiemannSolveAM\n+\n+ /*@@\n+ @routine RiemannSolvePolytypeAM\n+ @date Sep 1, 2010\n+ @author Joshua Faber, Scott Noble, Bruno Mundim, Ian Hawke\n+ @desc \n+ The same as above, just specializing to polytropic type EOS.\n+ Currently there is no point to this routine right now.\n+ @enddesc \n+ @calls \n+ @calledby \n+ @history \n+ \n+ @endhistory \n+\n+@@*/\n+\n+\n+subroutine RiemannSolvePolytypeAM(CCTK_ARGUMENTS)\n+\n+ implicit none\n+ \n+ DECLARE_CCTK_ARGUMENTS\n+ DECLARE_CCTK_PARAMETERS\n+ DECLARE_CCTK_FUNCTIONS\n+\n+ if (CCTK_EQUALS(riemann_solver,\"HLLE\")) then\n+ \n+ call GRHydro_HLLE_AM(CCTK_PASS_FTOF)\n+ \n+ if (evolve_tracer .ne. 0) then\n+ \n+!!$ Call the non-MHD version - see above\n+ \n+ call GRHydro_HLLE_Tracer(CCTK_PASS_FTOF)\n+ \n+ end if\n+ \n+!!$ else if (CCTK_EQUALS(riemann_solver,\"Roe\")) then \n+!!$ \n+!!$ call GRHydro_RoeSolve(CCTK_PASS_FTOF)\n+!!$\n+!!$ if (evolve_tracer .ne. 0) then\n+!!$ \n+!!$ call GRHydro_HLLE_Tracer(CCTK_PASS_FTOF)\n+!!$\n+!!$ end if\n+!!$ \n+!!$ else if (CCTK_EQUALS(riemann_solver,\"Marquina\")) then \n+!!$ \n+!!$ call GRHydro_Marquina(CCTK_PASS_FTOF)\n+ \n+!!$ Tracers are built directly in to the Marquina solver\n+ \n+ else\n+ \n+ call CCTK_ERROR(\"Roe and Marquina not implemented in MHD yet!!!\")\n+ STOP\n+\n+ end if\n+ \n+end subroutine RiemannSolvePolytypeAM\n+\n+\n+\n+\n+" }
{ "test_patch": "diff --git a/all_tests.txt b/all_tests.txt\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/all_tests.txt\n@@ -0,0 +1,10 @@\n+GRHydro_test_shock\n+GRHydro_test_shock_mp5\n+GRHydro_test_shock_ppm\n+GRHydro_test_tov_ppm_ML\n+GRHydro_test_tov_ppm_ML_disable_internal_excision\n+GRHydro_test_tov_ppm_no_trp_ML\n+test_one_hybrid\n+tov_carpetevolutionmask\n+tov_carpetevolutionmask2\n+tov_slowsector", "pass_criteria": "all_tests_pass" }
{ "scoring_method": "binary", "resolve_points": 100 }
MSB_einsteintoolkit_Cactus_pr2
multi_swe_bench
Add missing WaveMoLRegister.c in CactusExamples/WaveMoL (einsteintoolkit/Cactus#2)
{ "org": "einsteintoolkit", "repo": "Cactus", "pr_number": 2, "issue_title": "Add missing WaveMoLRegister.c in CactusExamples/WaveMoL", "issue_body": "This PR adds the missing source file WaveMoLRegister.c to complete the CactusExamples/WaveMoL thorn implementation.", "base_commit": "HEAD", "resolved_issues": [ { "number": 2, "title": "Implement the full functionality of WaveMoL", "body": "Please implement the full functionality of `WaveMoL` by finishing the code in `WaveMoLRegister.c`.\n\n## Thorn Information:\n- Name: WaveMoL\n- Target file: WaveMoLRegister.c\n\n## Interface Definition in interface.ccl:\n\n## Schedule Definition in schedule.ccl:\n\n## Parameters Definition in param.ccl:\n\n## Configuration Definition in configuration.ccl:\n\n## Documentation Context in readme.md and doc/documentation.tex\n\n## Related Code Context in src folder\n\n" } ], "commits": [], "diff_url": "", "patch_url": "", "html_url": "", "created_at": "", "merged_at": "" }
{ "env_type": "docker", "docker_image": "mswebench/einsteintoolkit_m_cactus:pr-2", "working_directory": "/testbed", "needs_build": true }
{ "fix_patch": "diff --git a/arrangements/CactusExamples/WaveMoL/src/WaveMoLRegister.c b/arrangements/CactusExamples/WaveMoL/src/WaveMoLRegister.c\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/arrangements/CactusExamples/WaveMoL/src/WaveMoLRegister.c\n@@ -0,0 +1,93 @@\n+ /*@@\n+ @file WaveMoLRegister.c\n+ @date Fri Nov 9 13:47:07 2001\n+ @author Ian Hawke\n+ @desc \n+ Routine to register the variables with the MoL thorn.\n+ @enddesc \n+ @@*/\n+\n+#include \"cctk.h\"\n+#include \"cctk_Arguments.h\"\n+#include \"cctk_Parameters.h\"\n+\n+static const char *rcsid = \"$Header$\";\n+\n+CCTK_FILEVERSION(CactusExamples_WaveMoL_WaveMoLRegister_c)\n+\n+/*\n+#ifndef DEBUG_MOL\n+#define DEBUG_MOL\n+#endif\n+*/\n+\n+void WaveMoL_RegisterVars(CCTK_ARGUMENTS);\n+\n+ /*@@\n+ @routine WaveMoL_RegisterVars\n+ @date Fri Nov 9 13:47:41 2001\n+ @author Ian Hawke\n+ @desc \n+ The registration routine.\n+ @enddesc \n+ @calls \n+ @calledby \n+ @history \n+ \n+ @endhistory \n+\n+@@*/\n+\n+void WaveMoL_RegisterVars(CCTK_ARGUMENTS)\n+{\n+\n+ DECLARE_CCTK_ARGUMENTS;\n+ DECLARE_CCTK_PARAMETERS;\n+\n+ CCTK_INT ierr = 0, group, rhs, var;\n+\n+ group = CCTK_GroupIndex(\"wavemol::scalarevolvemol_scalar\");\n+ rhs = CCTK_GroupIndex(\"wavemol::scalarrhsmol_scalar\");\n+\n+ if (CCTK_IsFunctionAliased(\"MoLRegisterEvolvedGroup\"))\n+ {\n+ ierr += MoLRegisterEvolvedGroup(group, rhs);\n+ }\n+ else\n+ {\n+ CCTK_WARN(0, \"MoL function not aliased\");\n+ ierr++;\n+ }\n+\n+ group = CCTK_GroupIndex(\"wavemol::scalarevolvemol_vector\");\n+ rhs = CCTK_GroupIndex(\"wavemol::scalarrhsmol_vector\");\n+\n+ if (CCTK_IsFunctionAliased(\"MoLRegisterEvolvedGroup\"))\n+ {\n+ ierr += MoLRegisterEvolvedGroup(group, rhs);\n+ }\n+ else\n+ {\n+ CCTK_WARN(0, \"MoL function MoLRegisterEvolvedGroup not aliased\");\n+ ierr++;\n+ }\n+\n+ var = CCTK_VarIndex(\"wavemol::energy\");\n+\n+ if (CCTK_IsFunctionAliased(\"MoLRegisterConstrained\"))\n+ {\n+ ierr += MoLRegisterConstrained(var);\n+ }\n+ else\n+ {\n+ CCTK_WARN(0, \"MoL function MoLRegisterConstrained not aliased\");\n+ ierr++;\n+ } \n+ \n+ if (ierr) CCTK_WARN(0,\"Problems registering with MoL\");\n+\n+#ifdef DEBUG_MOL\n+ printf(\"If we've got this far, then we've done with wavetoy registration.\\n\");\n+#endif \n+\n+}" }
{ "test_patch": "diff --git a/all_tests.txt b/all_tests.txt\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/all_tests.txt\n@@ -0,0 +1,1 @@\n+gaussian", "pass_criteria": "all_tests_pass" }
{ "scoring_method": "binary", "resolve_points": 100 }
MSB_einsteintoolkit_Cactus_pr20
multi_swe_bench
Add missing gauge.F in EinsteinInitialData/Exact (einsteintoolkit/Cactus#20)
{ "org": "einsteintoolkit", "repo": "Cactus", "pr_number": 20, "issue_title": "Add missing gauge.F in EinsteinInitialData/Exact", "issue_body": "This PR adds the missing source file gauge.F to complete the EinsteinInitialData/Exact thorn implementation.", "base_commit": "HEAD", "resolved_issues": [ { "number": 20, "title": "Implement the full functionality of Exact", "body": "Please implement the full functionality of `Exact` by finishing the code in `gauge.F`.\n\n## Thorn Information:\n- Name: Exact\n- Target file: gauge.F\n\n## Interface Definition in interface.ccl:\n\n## Schedule Definition in schedule.ccl:\n\n## Parameters Definition in param.ccl:\n\n## Configuration Definition in configuration.ccl:\n\n## Documentation Context in readme.md and doc/documentation.tex\n\n## Related Code Context in src folder\n\n" } ], "commits": [], "diff_url": "", "patch_url": "", "html_url": "", "created_at": "", "merged_at": "" }
{ "env_type": "docker", "docker_image": "mswebench/einsteintoolkit_m_cactus:pr-20", "working_directory": "/testbed", "needs_build": true }
{ "fix_patch": "diff --git a/arrangements/EinsteinInitialData/Exact/src/gauge.F b/arrangements/EinsteinInitialData/Exact/src/gauge.F\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/arrangements/EinsteinInitialData/Exact/src/gauge.F\n@@ -0,0 +1,187 @@\n+C This routine sets the lapse and/or shift by calling a routine\n+C that does it pointwise. Note that it could be easily modified\n+C to set the Bona-Masso variables B_xx etc. \n+C $Header$\n+\n+#include \"cctk.h\"\n+#include \"cctk_Parameters.h\"\n+#include \"cctk_Arguments.h\"\n+#include \"cctk_Functions.h\"\n+\n+ subroutine Exact__gauge(CCTK_ARGUMENTS)\n+\n+ implicit none\n+\n+ DECLARE_CCTK_ARGUMENTS\n+ DECLARE_CCTK_PARAMETERS\n+ DECLARE_CCTK_FUNCTIONS\n+\n+ integer i,j,k\n+ integer nx,ny,nz\n+ logical set_lapse, set_dtlapse, set_shift, set_dtshift\n+\n+ CCTK_REAL tt, xx, yy, zz\n+ CCTK_REAL gxxtmp, gyytmp, gzztmp, \n+ $ gxytmp, gyztmp, gxztmp,\n+ $ hxxtmp, hyytmp, hzztmp, \n+ $ hxytmp, hyztmp, hxztmp,\n+ $ dxgxxtmp, dxgyytmp, dxgzztmp, \n+ $ dxgxytmp, dxgyztmp, dxgxztmp,\n+ $ dygxxtmp, dygyytmp, dygzztmp, \n+ $ dygxytmp, dygyztmp, dygxztmp,\n+ $ dzgxxtmp, dzgyytmp, dzgzztmp, \n+ $ dzgxytmp, dzgyztmp, dzgxztmp,\n+ $ alptmp, dtalptmp, axtmp, aytmp, aztmp, \n+ $ betaxtmp, betaytmp, betaztmp,\n+ $ dtbetaxtmp, dtbetaytmp, dtbetaztmp,\n+ $ bxxtmp, bxytmp, bxztmp, \n+ $ byxtmp, byytmp, byztmp, \n+ $ bzxtmp, bzytmp, bzztmp\n+ CCTK_REAL\n+ $ exact_psi,\n+ $ exact_psix, exact_psiy, exact_psiz,\n+ $ exact_psixx, exact_psiyy, exact_psizz,\n+ $ exact_psixy, exact_psiyz, exact_psixz\n+ LOGICAL is_initial_slice, is_later_slice\n+\n+C are we on the initial slice or some later slice?\n+C n.b. the logical expressions later in this function involving\n+C these flags below would be *so* much nicer if Fortran\n+C grokked C-style conditional expressions... :) :)\n+ is_initial_slice = cctk_iteration .eq. 0\n+ is_later_slice = cctk_iteration .ne. 0\n+\n+C Grid parameters.\n+ nx = cctk_lsh(1)\n+ ny = cctk_lsh(2)\n+ nz = cctk_lsh(3)\n+\n+C This code used to set t = time + dt/2 to get 2nd order accuracy,\n+C but this leads to the initial data being set at the wrong time. :(\n+C In the context of MoL, we want to set variables at the standard Cactus\n+C time (cctk_time), because MoL takes care of calling us at each MoL\n+C iteration, and updating the field variables appropriately.\n+C\n+C Alas, setting at cctk_time probably gives O(dt) errors for non-MoL\n+C evoutions where Exact is used to set stuff at each time step.\n+C Fixing this [unless we just declare all non-MoL stuff obselete :) ]\n+C probably requires cleaning up our (++messy) schedule.ccl , which\n+C is why this remains a bug for now... :( :(\n+\n+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n+\n+C\n+C Set lapse and/or shift?\n+C\n+ if ( is_initial_slice ) then\n+ set_lapse = CCTK_Equals(initial_lapse, \"exact\").ne.0\n+ set_shift = CCTK_Equals(initial_shift, \"exact\").ne.0\n+ set_dtlapse = CCTK_Equals(initial_dtlapse, \"exact\").ne.0\n+ set_dtshift = CCTK_Equals(initial_dtshift, \"exact\").ne.0\n+ end if\n+ if ( is_later_slice ) then\n+ set_lapse = CCTK_Equals(lapse_evolution_method, \"exact\").ne.0\n+ set_shift = CCTK_Equals(shift_evolution_method, \"exact\").ne.0\n+ set_dtlapse = CCTK_Equals(dtlapse_evolution_method, \"exact\").ne.0\n+ set_dtshift = CCTK_Equals(dtshift_evolution_method, \"exact\").ne.0\n+ end if\n+\n+ if ( set_lapse .or. set_shift .or. set_dtlapse .or. set_dtshift) then\n+\n+C$omp parallel do private (\n+C$omp$ i, j, k,\n+C$omp$ tt, xx, yy, zz,\n+C$omp$ alptmp, dtalptmp, axtmp, aytmp, aztmp, \n+C$omp$ betaxtmp, betaytmp, betaztmp,\n+C$omp$ dtbetaxtmp, dtbetaytmp, dtbetaztmp,\n+C$omp$ bxxtmp, bxytmp, bxztmp, \n+C$omp$ byxtmp, byytmp, byztmp, \n+C$omp$ bzxtmp, bzytmp, bzztmp,\n+C$omp$ dxgxxtmp, dxgyytmp, dxgzztmp, \n+C$omp$ dxgxytmp, dxgyztmp, dxgxztmp,\n+C$omp$ dygxxtmp, dygyytmp, dygzztmp, \n+C$omp$ dygxytmp, dygyztmp, dygxztmp,\n+C$omp$ dzgxxtmp, dzgyytmp, dzgzztmp, \n+C$omp$ dzgxytmp, dzgyztmp, dzgxztmp,\n+C$omp$ exact_psi,\n+C$omp$ exact_psix, exact_psiy, exact_psiz,\n+C$omp$ exact_psixx, exact_psiyy, exact_psizz,\n+C$omp$ exact_psixy, exact_psiyz, exact_psixz)\n+ do k=1,nz\n+ do j=1,ny\n+ do i=1,nx\n+\n+ tt = cctk_time\n+ xx = x(i,j,k) - cctk_time * shift_add_x\n+ yy = y(i,j,k) - cctk_time * shift_add_y\n+ zz = z(i,j,k) - cctk_time * shift_add_z\n+\n+C Initialize the psi of exact\n+C (also to tell the models about the conformal_state)\n+ if (conformal_state .ne. 0) then\n+ exact_psi = 1.0D0\n+ else\n+ exact_psi = 0.0D0\n+ end if\n+ exact_psix = 0.0D0\n+ exact_psiy = 0.0D0\n+ exact_psiz = 0.0D0\n+ exact_psixx = 0.0D0\n+ exact_psiyy = 0.0D0\n+ exact_psizz = 0.0D0\n+ exact_psixy = 0.0D0\n+ exact_psiyz = 0.0D0\n+ exact_psixz = 0.0D0\n+\n+ call Exact__Bona_Masso_data(\n+ $ decoded_exact_model,\n+ $ xx, yy, zz, tt,\n+ $ gxxtmp, gyytmp, gzztmp, \n+ $ gxytmp, gyztmp, gxztmp,\n+ $ hxxtmp, hyytmp, hzztmp, \n+ $ hxytmp, hyztmp, hxztmp,\n+ $ exact_psi,\n+ $ exact_psix, exact_psiy, exact_psiz,\n+ $ exact_psixx, exact_psiyy, exact_psizz,\n+ $ exact_psixy, exact_psiyz, exact_psixz,\n+ $ dxgxxtmp, dxgyytmp, dxgzztmp, \n+ $ dxgxytmp, dxgyztmp, dxgxztmp,\n+ $ dygxxtmp, dygyytmp, dygzztmp, \n+ $ dygxytmp, dygyztmp, dygxztmp,\n+ $ dzgxxtmp, dzgyytmp, dzgzztmp, \n+ $ dzgxytmp, dzgyztmp, dzgxztmp,\n+ $ alptmp, dtalptmp, axtmp, aytmp, aztmp, \n+ $ betaxtmp, betaytmp, betaztmp,\n+ $ dtbetaxtmp, dtbetaytmp, dtbetaztmp,\n+ $ bxxtmp, bxytmp, bxztmp, \n+ $ byxtmp, byytmp, byztmp, \n+ $ bzxtmp, bzytmp, bzztmp)\n+\n+ if ( set_lapse ) then\n+ alp(i,j,k) = alptmp\n+ end if\n+ if ( set_shift ) then\n+ betax(i,j,k) = betaxtmp + shift_add_x\n+ betay(i,j,k) = betaytmp + shift_add_y\n+ betaz(i,j,k) = betaztmp + shift_add_z\n+ end if\n+ if ( set_dtlapse ) then\n+ dtalp(i,j,k) = dtalptmp\n+ end if\n+ if ( set_dtshift ) then\n+ dtbetax(i,j,k) = dtbetaxtmp\n+ dtbetay(i,j,k) = dtbetaytmp\n+ dtbetaz(i,j,k) = dtbetaztmp\n+ end if\n+ end do\n+ end do\n+ end do\n+\n+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n+\n+ else\n+ call CCTK_WARN(1,'Exact__gauge has been called without doing anything')\n+ end if\n+\n+ return\n+ end" }
{ "test_patch": "diff --git a/all_tests.txt b/all_tests.txt\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/all_tests.txt\n@@ -0,0 +1,2 @@\n+Schwarzschild_EF\n+bowl-init", "pass_criteria": "all_tests_pass" }
{ "scoring_method": "binary", "resolve_points": 100 }
MSB_einsteintoolkit_Cactus_pr21
multi_swe_bench
Add missing metrics/de_Sitter.F in EinsteinInitialData/Exact (einsteintoolkit/Cactus#21)
{ "org": "einsteintoolkit", "repo": "Cactus", "pr_number": 21, "issue_title": "Add missing metrics/de_Sitter.F in EinsteinInitialData/Exact", "issue_body": "This PR adds the missing source file metrics/de_Sitter.F to complete the EinsteinInitialData/Exact thorn implementation.", "base_commit": "HEAD", "resolved_issues": [ { "number": 21, "title": "Implement the full functionality of Exact", "body": "Please implement the full functionality of `Exact` by finishing the code in `metrics/de_Sitter.F`.\n\n## Thorn Information:\n- Name: Exact\n- Target file: metrics/de_Sitter.F\n\n## Interface Definition in interface.ccl:\n\n## Schedule Definition in schedule.ccl:\n\n## Parameters Definition in param.ccl:\n\n## Configuration Definition in configuration.ccl:\n\n## Documentation Context in readme.md and doc/documentation.tex\n\n## Related Code Context in src folder\n\n" } ], "commits": [], "diff_url": "", "patch_url": "", "html_url": "", "created_at": "", "merged_at": "" }
{ "env_type": "docker", "docker_image": "mswebench/einsteintoolkit_m_cactus:pr-21", "working_directory": "/testbed", "needs_build": true }
{ "fix_patch": "diff --git a/arrangements/EinsteinInitialData/Exact/src/metrics/de_Sitter.F b/arrangements/EinsteinInitialData/Exact/src/metrics/de_Sitter.F\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/arrangements/EinsteinInitialData/Exact/src/metrics/de_Sitter.F\n@@ -0,0 +1,79 @@\n+C Einstein-DeSitter metric spacetime !!!!\n+C It emulates the Robertson-Walker universe\n+C near t=0, with zero pressure, and k=0\n+C See :J.N. Islam, An Introduction to \n+C Mathematical Cosmology, Cambridge, 1992 and \n+C S. Hawking, G.F.R. Ellis, The Large Scale\n+C Structure of space-time, Cambridge, 1973\n+C\n+C Author : D. Vulcanov (Timisoara, Romania)\n+C see ../../README for copyright & licensing info\n+C\n+C $Header$\n+\n+#include \"cctk.h\"\n+#include \"cctk_Parameters.h\"\n+\n+ subroutine Exact__de_Sitter(\n+ $ x, y, z, t,\n+ $ gdtt, gdtx, gdty, gdtz, \n+ $ gdxx, gdyy, gdzz, gdxy, gdyz, gdzx,\n+ $ gutt, gutx, guty, gutz, \n+ $ guxx, guyy, guzz, guxy, guyz, guzx,\n+ $ psi, Tmunu_flag)\n+\n+ implicit none\n+\n+ DECLARE_CCTK_PARAMETERS\n+\n+c input arguments\n+ CCTK_DECLARE(CCTK_REAL, x,)\n+ CCTK_DECLARE(CCTK_REAL, y,)\n+ CCTK_DECLARE(CCTK_REAL, z,)\n+ CCTK_REAL t\n+\n+c output arguments\n+ CCTK_REAL gdtt, gdtx, gdty, gdtz, \n+ $ gdxx, gdyy, gdzz, gdxy, gdyz, gdzx,\n+ $ gutt, gutx, guty, gutz, \n+ $ guxx, guyy, guzz, guxy, guyz, guzx\n+ CCTK_DECLARE(CCTK_REAL, psi,)\n+ LOGICAL Tmunu_flag\n+\n+c local variables\n+ CCTK_REAL arad\n+ CCTK_REAL am\n+\n+C This model has a cosmological constant\n+C ==> it sets the stress-energy tensor in the \"CalcTmunu\" code\n+ Tmunu_flag = .true.\n+\n+ arad = de_Sitter__scale\n+ \n+ am=arad*t**(4.0D0/3.0D0) \n+\n+ gdtt = -1.0D0 \n+ gdtx = 0.0D0 \n+ gdty = 0.0D0\n+ gdtz = 0.0D0\n+ gdxx = am\n+ gdyy = am\n+ gdzz = am\n+ gdxy = 0.d0\n+ gdyz = 0.d0\n+ gdzx = 0.d0\n+\n+ gutt = -1.d0\n+ gutx = 0.d0\n+ guty = 0.d0\n+ gutz = 0.d0\n+ guxx = 1.d0/am\n+ guyy = 1.d0/am\n+ guzz = 1.d0/am\n+ guxy = 0.d0\n+ guyz = 0.d0\n+ guzx = 0.d0\n+\n+\n+ return\n+ end" }
{ "test_patch": "diff --git a/all_tests.txt b/all_tests.txt\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/all_tests.txt\n@@ -0,0 +1,2 @@\n+Schwarzschild_EF\n+bowl-init", "pass_criteria": "all_tests_pass" }
{ "scoring_method": "binary", "resolve_points": 100 }
MSB_einsteintoolkit_Cactus_pr22
multi_swe_bench
Add missing metrics/Schwarzschild_EF.F in EinsteinInitialData/Exact (einsteintoolkit/Cactus#22)
{ "org": "einsteintoolkit", "repo": "Cactus", "pr_number": 22, "issue_title": "Add missing metrics/Schwarzschild_EF.F in EinsteinInitialData/Exact", "issue_body": "This PR adds the missing source file metrics/Schwarzschild_EF.F to complete the EinsteinInitialData/Exact thorn implementation.", "base_commit": "HEAD", "resolved_issues": [ { "number": 22, "title": "Implement the full functionality of Exact", "body": "Please implement the full functionality of `Exact` by finishing the code in `metrics/Schwarzschild_EF.F`.\n\n## Thorn Information:\n- Name: Exact\n- Target file: metrics/Schwarzschild_EF.F\n\n## Interface Definition in interface.ccl:\n\n## Schedule Definition in schedule.ccl:\n\n## Parameters Definition in param.ccl:\n\n## Configuration Definition in configuration.ccl:\n\n## Documentation Context in readme.md and doc/documentation.tex\n\n## Related Code Context in src folder\n\n" } ], "commits": [], "diff_url": "", "patch_url": "", "html_url": "", "created_at": "", "merged_at": "" }
{ "env_type": "docker", "docker_image": "mswebench/einsteintoolkit_m_cactus:pr-22", "working_directory": "/testbed", "needs_build": true }
{ "fix_patch": "diff --git a/arrangements/EinsteinInitialData/Exact/src/metrics/Schwarzschild_EF.F b/arrangements/EinsteinInitialData/Exact/src/metrics/Schwarzschild_EF.F\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/arrangements/EinsteinInitialData/Exact/src/metrics/Schwarzschild_EF.F\n@@ -0,0 +1,75 @@\n+c Schwarzschild metric in Eddington-Finkelstein coordinates,\n+c as per MTW box 31.2\n+C\n+C Author: unknown\n+C Copyright/License: unknown\n+C\n+c $Header$\n+\n+#include \"cctk.h\"\n+#include \"cctk_Parameters.h\"\n+\n+ subroutine Exact__Schwarzschild_EF(\n+ $ x, y, z, t,\n+ $ gdtt, gdtx, gdty, gdtz, \n+ $ gdxx, gdyy, gdzz, gdxy, gdyz, gdzx,\n+ $ gutt, gutx, guty, gutz, \n+ $ guxx, guyy, guzz, guxy, guyz, guzx,\n+ $ psi, Tmunu_flag)\n+\n+ implicit none\n+\n+ DECLARE_CCTK_PARAMETERS\n+\n+c input arguments\n+ CCTK_REAL x, y, z\n+ CCTK_DECLARE(CCTK_REAL, t,)\n+\n+c output arguments\n+ CCTK_REAL gdtt, gdtx, gdty, gdtz, \n+ $ gdxx, gdyy, gdzz, gdxy, gdyz, gdzx,\n+ $ gutt, gutx, guty, gutz, \n+ $ guxx, guyy, guzz, guxy, guyz, guzx\n+ CCTK_DECLARE(CCTK_REAL, psi,)\n+ LOGICAL Tmunu_flag\n+\n+c local static variables\n+ CCTK_REAL eps, m\n+\n+c local variables\n+ CCTK_REAL r\n+\n+C This is a vacuum spacetime with no cosmological constant\n+ Tmunu_flag = .false.\n+\n+C Get parameters of the exact solution.\n+\n+ eps = Schwarzschild_EF__epsilon\n+ m = Schwarzschild_EF__mass\n+\n+ r = max(sqrt(x**2 + y**2 + z**2), eps)\n+\n+ gdtt = - (1.d0 - 2.d0 * m / r)\n+ gdtx = 2.d0 * m * x / r**2\n+ gdty = 2.d0 * m * y / r**2\n+ gdtz = 2.d0 * m * z / r**2\n+ gdxx = 1.d0 + 2.d0 * m * x**2 / r**3\n+ gdyy = 1.d0 + 2.d0 * m * y**2 / r**3\n+ gdzz = 1.d0 + 2.d0 * m * z**2 / r**3\n+ gdxy = 2.d0 * m * x * y / r**3\n+ gdyz = 2.d0 * m * y * z / r**3\n+ gdzx = 2.d0 * m * z * x / r**3\n+\n+ gutt = - (1.d0 + 2.d0 * m / r)\n+ gutx = 2.d0 * m * x / r**2\n+ guty = 2.d0 * m * y / r**2\n+ gutz = 2.d0 * m * z / r**2\n+ guxx = 1.d0 - 2.d0 * m * x**2 / r**3\n+ guyy = 1.d0 - 2.d0 * m * y**2 / r**3\n+ guzz = 1.d0 - 2.d0 * m * z**2 / r**3\n+ guxy = - 2.d0 * m * x * y / r**3\n+ guyz = - 2.d0 * m * y * z / r**3\n+ guzx = - 2.d0 * m * z * x / r**3\n+\n+ return\n+ end" }
{ "test_patch": "diff --git a/all_tests.txt b/all_tests.txt\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/all_tests.txt\n@@ -0,0 +1,2 @@\n+Schwarzschild_EF\n+bowl-init", "pass_criteria": "all_tests_pass" }
{ "scoring_method": "binary", "resolve_points": 100 }
MSB_einsteintoolkit_Cactus_pr23
multi_swe_bench
Add missing Misner_standard.c in EinsteinInitialData/IDAnalyticBH (einsteintoolkit/Cactus#23)
{ "org": "einsteintoolkit", "repo": "Cactus", "pr_number": 23, "issue_title": "Add missing Misner_standard.c in EinsteinInitialData/IDAnalyticBH", "issue_body": "This PR adds the missing source file Misner_standard.c to complete the EinsteinInitialData/IDAnalyticBH thorn implementation.", "base_commit": "HEAD", "resolved_issues": [ { "number": 23, "title": "Implement the full functionality of IDAnalyticBH", "body": "Please implement the full functionality of `IDAnalyticBH` by finishing the code in `Misner_standard.c`.\n\n## Thorn Information:\n- Name: IDAnalyticBH\n- Target file: Misner_standard.c\n\n## Interface Definition in interface.ccl:\n\n## Schedule Definition in schedule.ccl:\n\n## Parameters Definition in param.ccl:\n\n## Configuration Definition in configuration.ccl:\n\n## Documentation Context in readme.md and doc/documentation.tex\n\n## Related Code Context in src folder\n\n" } ], "commits": [], "diff_url": "", "patch_url": "", "html_url": "", "created_at": "", "merged_at": "" }
{ "env_type": "docker", "docker_image": "mswebench/einsteintoolkit_m_cactus:pr-23", "working_directory": "/testbed", "needs_build": true }
{ "fix_patch": "diff --git a/arrangements/EinsteinInitialData/IDAnalyticBH/src/Misner_standard.c b/arrangements/EinsteinInitialData/IDAnalyticBH/src/Misner_standard.c\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/arrangements/EinsteinInitialData/IDAnalyticBH/src/Misner_standard.c\n@@ -0,0 +1,284 @@\n+ /*@@\n+ @file Misner_standard.c\n+ @date March 1997\n+ @author Joan Masso\n+ @desc\n+ Set up initial data for two Misner black holes\n+ @enddesc\n+ @history\n+ @hdate Sun Oct 17 11:05:48 1999 @hauthor Tom Goodale\n+ @hdesc Converted to C\n+ @endhistory\n+ @version $Header$\n+ @@*/\n+\n+#include <math.h>\n+#include <string.h>\n+#include <stdlib.h>\n+\n+#include \"cctk.h\"\n+#include \"cctk_Arguments.h\"\n+#include \"cctk_Parameters.h\"\n+\n+#include \"IDAnalyticBH.h\"\n+\n+static const char *rcsid = \"$Header$\";\n+\n+CCTK_FILEVERSION(CactusEinstein_IDAnalyticBH_Misner_standard_c)\n+\n+ /*@@\n+ @routine Misner_standard\n+ @date\n+ @author Joan Masso, Ed Seidel\n+ @desc\n+ Initialize the metric with a time symmetrical\n+ black hole spacetime containing\n+ two axially symmetric misner black holes with a\n+ mass/length parameter mu. The mass is computed.\n+ The spacetime line element has the form:\n+ $$ ds^2 = -dt^2 + \\Psi^4 (dx^2+dy^2+dz^2) $$\n+ and only $\\Psi$ differs.\n+ (Conformal factor from Karen Camarda)\n+ @enddesc\n+\n+ @par mu\n+ @pdesc Misner parameter.\n+ @ptype real\n+ @pcomment Values less than 1.8 do not really correspond to two\n+ black holes, as there is an initial single event horizon\n+ surrounding the throats. So, with low values of mu we also\n+ have distorted single black holes.\n+ @endpar\n+\n+ @par nmax\n+ @pdesc Summation limit for the misner series in the 'twobh' case.\n+ @ptype integer\n+ @endpar\n+ @history\n+ @hdate Fri Apr 26 10:04:05 2002 @hauthor Tom Goodale\n+ @hdesc Changed to use new StaticConformal stuff\n+ @endhistory \n+\n+@@*/\n+void Misner_standard(CCTK_ARGUMENTS)\n+{\n+ DECLARE_CCTK_ARGUMENTS\n+ DECLARE_CCTK_PARAMETERS\n+\n+ int i, n;\n+ int npoints;\n+ CCTK_REAL *csch, *coth, inv_r1, inv_r2;\n+ CCTK_REAL x_squared, y_squared, xy_squared;\n+ CCTK_REAL inv_r1_cubed, inv_r2_cubed;\n+ CCTK_REAL inv_r1_5, inv_r2_5;\n+ CCTK_REAL inv_psi;\n+ CCTK_INT powfac;\n+ CCTK_REAL adm_mass;\n+ const CCTK_REAL zero = 0.0, one = 1.0, three = 3.0;\n+ int make_conformal_derivs = 0;\n+\n+ CCTK_VInfo(CCTK_THORNSTRING,\n+ \"setting up Misner initial data\");\n+\n+ /* Check if we should create and store conformal factor stuff */\n+ if(CCTK_EQUALS(metric_type, \"static conformal\"))\n+ {\n+ if (CCTK_EQUALS(conformal_storage,\"factor\"))\n+ {\n+ *conformal_state = 1;\n+ make_conformal_derivs = 0;\n+ }\n+ else if (CCTK_EQUALS(conformal_storage,\"factor+derivs\"))\n+ {\n+ *conformal_state = 2;\n+ make_conformal_derivs = 1;\n+ }\n+ else if (CCTK_EQUALS(conformal_storage,\"factor+derivs+2nd derivs\"))\n+ {\n+ *conformal_state = 3;\n+ make_conformal_derivs = 1;\n+ }\n+ else\n+ {\n+ CCTK_VWarn(0, __LINE__, __FILE__, CCTK_THORNSTRING,\n+\"Misner_Standard(): impossible value for conformal_storage=\\\"%s\\\"!\",\n+ conformal_storage); /*NOTREACHED*/\n+ }\n+ } \n+\n+ /* total number of points on this processor */\n+ npoints = cctk_lsh[0] * cctk_lsh[1] * cctk_lsh[2];\n+\n+\n+ /* Initialize so we can accumulate\n+ * -------------------------------\n+ */\n+ if (make_conformal_derivs)\n+ {\n+ IDAnalyticBH_zero_CCTK_REAL_array(npoints, psix);\n+ IDAnalyticBH_zero_CCTK_REAL_array(npoints, psiy);\n+ IDAnalyticBH_zero_CCTK_REAL_array(npoints, psiz);\n+\n+ if(*conformal_state > 2)\n+ {\n+ IDAnalyticBH_zero_CCTK_REAL_array(npoints, psixx);\n+ IDAnalyticBH_zero_CCTK_REAL_array(npoints, psixy);\n+ IDAnalyticBH_zero_CCTK_REAL_array(npoints, psixz);\n+ IDAnalyticBH_zero_CCTK_REAL_array(npoints, psiyy);\n+ IDAnalyticBH_zero_CCTK_REAL_array(npoints, psiyz);\n+ IDAnalyticBH_zero_CCTK_REAL_array(npoints, psizz);\n+ }\n+ }\n+\n+ csch = (CCTK_REAL *) malloc (2 * (nmax + 1) * sizeof (CCTK_REAL));\n+ coth = csch + nmax + 1;\n+\n+ /* compute the ADM mass\n+ * --------------------\n+ */\n+ adm_mass = zero;\n+ for(n = 1; n <= nmax; n++)\n+ {\n+ csch[n] = one / sinh(mu*n);\n+ coth[n] = one / tanh(mu*n);\n+ adm_mass += 4.0 * csch[n];\n+ }\n+ CCTK_VInfo(CCTK_THORNSTRING, \"ADM mass is %f\", (double) adm_mass);\n+\n+\n+ for(i = 0; i < npoints; i++)\n+ {\n+ psi [i] = one;\n+\n+ x_squared = SQR(x[i]);\n+ y_squared = SQR(y[i]);\n+ xy_squared = x_squared + y_squared;\n+\n+ for(n = nmax; n >= 1; n--)\n+ {\n+ inv_r1 = one / sqrt(xy_squared+SQR(z[i]+coth[n]));\n+ inv_r2 = one / sqrt(xy_squared+SQR(z[i]-coth[n]));\n+\n+ psi[i] += csch[n]*(inv_r1 + inv_r2);\n+\n+ if (make_conformal_derivs)\n+ {\n+ inv_r1_cubed = inv_r1 * inv_r1 * inv_r1;\n+ inv_r2_cubed = inv_r2 * inv_r2 * inv_r2;\n+ inv_r1_5 = inv_r1 * inv_r1 * inv_r1_cubed;\n+ inv_r2_5 = inv_r2 * inv_r2 * inv_r2_cubed;\n+ psix[i] += -x[i] * (inv_r2_cubed + inv_r1_cubed) * csch[n];\n+ psiy[i] += -y[i] * (inv_r2_cubed + inv_r1_cubed) * csch[n];\n+ psiz[i] += (-(z[i]-coth[n])*inv_r2_cubed - (z[i]+coth[n])*inv_r1_cubed) * csch[n];\n+\n+\n+ if(*conformal_state > 2)\n+ {\n+ psixx[i] += (three*x_squared*(inv_r1_5 + inv_r2_5)\n+ - inv_r1_cubed - inv_r2_cubed) * csch[n];\n+ psixy[i] += three*x[i]*y[i]*(inv_r1_5 + inv_r2_5) * csch[n];\n+ psixz[i] += (three*x[i]*(z[i] - coth[n])*inv_r2_5\n+ + three*x[i]*(z[i] + coth[n])*inv_r1_5) * csch[n];\n+ psiyy[i] += (three*y_squared*(inv_r1_5 + inv_r2_5)\n+ - inv_r1_cubed - inv_r2_cubed) * csch[n];\n+ psiyz[i] += (three*y[i]*(z[i] - coth[n])*inv_r2_5\n+ + three*y[i]*(z[i] + coth[n])*inv_r1_5) * csch[n];\n+ psizz[i] += (-inv_r2_cubed+three*SQR(z[i] - coth[n])*inv_r2_5\n+ + three*SQR(z[i] + coth[n])*inv_r1_5 - inv_r1_cubed) * csch[n];\n+ }\n+ }\n+ }\n+\n+ /* Cactus convention\n+ * -----------------\n+ */\n+ if (make_conformal_derivs)\n+ {\n+ inv_psi = one / psi[i];\n+\n+ psix[i] *= inv_psi;\n+ psiy[i] *= inv_psi;\n+ psiz[i] *= inv_psi;\n+\n+ if(*conformal_state > 2)\n+ {\n+ psixx[i] *= inv_psi;\n+ psixy[i] *= inv_psi;\n+ psixz[i] *= inv_psi;\n+ psiyy[i] *= inv_psi;\n+ psiyz[i] *= inv_psi;\n+ psizz[i] *= inv_psi;\n+ }\n+ }\n+ }\n+\n+ /* Should initialize lapse to Cadez value if possible\n+ * --------------------------------------------------\n+ */\n+\n+ if (CCTK_Equals(initial_lapse,\"cadez\"))\n+ {\n+ CCTK_INFO(\"Initialise with cadez lapse\");\n+\n+ for(i = 0; i < npoints; i++)\n+ {\n+ xy_squared = SQR(x[i]) + SQR(y[i]);\n+\n+ alp[i] = one;\n+\n+ powfac = 1;\n+\n+ for(n = 1; n <= nmax; n++)\n+ {\n+ inv_r1 = one / sqrt(xy_squared+SQR(z[i]+coth[n]));\n+ inv_r2 = one / sqrt(xy_squared+SQR(z[i]-coth[n]));\n+ powfac = -powfac;\n+\n+ alp[i] += powfac * csch[n] * (inv_r1 + inv_r2);\n+ }\n+\n+ alp[i] /= psi[i];\n+ }\n+ }\n+\n+ /* Metric depends on conformal state\n+ * ---------------------------------\n+ */\n+\n+ if (CCTK_EQUALS(metric_type, \"static conformal\"))\n+ {\n+ for(i = 0; i < npoints; i++)\n+ {\n+ gxx[i] = one;\n+ gyy[i] = one;\n+ gzz[i] = one;\n+ }\n+ }\n+ else\n+ {\n+ for(i = 0; i < npoints; i++)\n+ {\n+ gxx[i] = psi[i] * psi[i] * psi[i] * psi[i];\n+ gyy[i] = gxx[i];\n+ gzz[i] = gxx[i];\n+ }\n+ }\n+ IDAnalyticBH_zero_CCTK_REAL_array(npoints, gxy);\n+ IDAnalyticBH_zero_CCTK_REAL_array(npoints, gxz);\n+ IDAnalyticBH_zero_CCTK_REAL_array(npoints, gyz);\n+\n+ /* Time-symmetric data\n+ * -------------------\n+ */\n+ IDAnalyticBH_zero_CCTK_REAL_array(npoints, kxx);\n+ IDAnalyticBH_zero_CCTK_REAL_array(npoints, kxy);\n+ IDAnalyticBH_zero_CCTK_REAL_array(npoints, kxz);\n+ IDAnalyticBH_zero_CCTK_REAL_array(npoints, kyy);\n+ IDAnalyticBH_zero_CCTK_REAL_array(npoints, kyz);\n+ IDAnalyticBH_zero_CCTK_REAL_array(npoints, kzz);\n+\n+ if (csch)\n+ {\n+ free (csch);\n+ }\n+}" }
{ "test_patch": "diff --git a/all_tests.txt b/all_tests.txt\nnew file mode 100644\nindex 0000000..0000000\n--- /dev/null\n+++ b/all_tests.txt\n@@ -0,0 +1,3 @@\n+kerr\n+test_bl\n+test_misner", "pass_criteria": "all_tests_pass" }
{ "scoring_method": "binary", "resolve_points": 100 }
End of preview. Expand in Data Studio

AInsteinBench

AInsteinBench is a benchmark for evaluating the capabilities of AI agents in solving scientific computing problems. It currently supports Einstein Toolkit and Multi-SWE-bench formats of coding questions.

πŸ“Š Dataset Overview

AInsteinBench provides 244 scientific computing tasks derived from multiple scientific repositories. These tasks have been verified on execution and also reviewed by corresponding domain experts to verify both software engineering and scientific content accuracy. The tasks cover numerical relativity, quantum information, molecular dynamics, cheminformatics and quantum chemistry.

πŸ“‹ Data Fields

The questions are formatted following the AInsteinBench format:

{
    "question_id": str,        # Unique identifier
    "question_type": str,      # currently supporting "einstein_toolkit" or "multi_swe_bench"
    "description": str,        # Task description
    "content": dict,           # Full problem context
    "environment": dict,       # environment such as docker images
    "answer": dict,            # reference answer following the format of the question type
    "test": dict,              # Test cases and how to run them
    "scoring_config": dict     # Scoring configuration
}

πŸ”¬ Data Curation Process

Multi-SWE-Bench Processing (msb_type)

244 tasks from real-world development process of scientific computing repositories:

  • Sources: OpenMM, PySCF, RDkit, Qiskit, AMReX, EinsteinToolkit (EisnteinToolkit problems are synthesized. Others are from real issues and pull requests)
  • Languages: C++ (~65%), Python (~35%)
  • Tasks: Bug fixes, feature implementation, code completion

Data is formatted following the Multi-SWE-Bench structure with issue descriptions, patches, and test cases.

Einstein Toolkit Processing (et_type)

The Einstein Toolkit is a collection of C/C++/Fortran codes for general relativistic simulations, organized into packages called "Thorns" managed by the Cactus Computation Language (CCL).

Thorn Structure:

.
β”œβ”€β”€ doc/                       # Documentation
β”‚   └── documentation.tex
β”œβ”€β”€ src/                       # Source code (one file removed as target)
β”‚   └── *.c, *.cpp, *.f90
β”œβ”€β”€ test/                      # Test cases
β”‚   β”œβ”€β”€ <test_name>/          # Reference outputs
β”‚   └── <test_name>.par       # Test parameters
β”œβ”€β”€ README.md
β”œβ”€β”€ configuration.ccl          # Dependencies
β”œβ”€β”€ interface.ccl              # Shared variables/functions
β”œβ”€β”€ param.ccl                  # Parameters
└── schedule.ccl               # Execution scheduling

Problem Definition: Given an incomplete Thorn (missing one source file), can the model complete it and pass all tests?

Data Curation Pipeline:

  1. Collected ~3,000 questions from open-sourced Einstein Toolkit Thorns
  2. Screened for 1,085 questions with runnable tests (the questions verified on execution are provided in et_type)
  3. Manually verified and selected 40 questions where models are evaluated on physical reasoning abilities, in addition to software engineering skills. (merged to msb_type)

πŸ’» Usage

Loading the Dataset

from datasets import load_dataset

# Load the default subset (msb_type)
dataset = load_dataset("ByteDance-Seed/AInsteinBench")

# Load specific subsets
msb_dataset = load_dataset("ByteDance-Seed/AInsteinBench", "msb_type")
et_dataset = load_dataset("ByteDance-Seed/AInsteinBench", "et_type")

# Access samples
for sample in dataset['train']:
    print(f"ID: {sample['question_id']}")
    print(f"Type: {sample['question_type']}")
    print(f"Task: {sample['description']}")

Evaluation

For evaluation scripts and detailed usage, please visit the AInsteinBench GitHub repository.

πŸ“œ License

The dataset is licensed under CC0, subject to any intellectual property rights in the dataset. The data is adapted from open source projects; your use of that data must comply with their respective licenses.

Source Repositories:

🀝 Citation

If you use AInsteinBench in your research, please cite:

@dataset{ainsteinbench2025dataset,
  title={AInsteinBench: Benchmarking Coding Agents on Scientific Repositories},
  author={ByteDance Seed Team},
  year={2025},
  publisher={Hugging Face},
  url={https://huggingface.co/datasets/ByteDance-Seed/AInsteinBench}
}
Downloads last month
24