From 56487d8a80ca90ce946429a3b272ec211f8e3464 Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Tue, 14 Jan 2020 13:27:23 -0800 Subject: [PATCH 001/120] adding pulsar as a compiler option --- Source/Make.WarpX | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/Source/Make.WarpX b/Source/Make.WarpX index c2994022d43..b13177a0fcd 100644 --- a/Source/Make.WarpX +++ b/Source/Make.WarpX @@ -64,6 +64,10 @@ else endif endif +ifeq ($(PULSAR),TRUE) + DEFINES += -DPULSAR +endif + -include Make.package include $(WARPX_HOME)/Source/Make.package include $(WARPX_HOME)/Source/BoundaryConditions/Make.package From d3f38b28f4692aa976f9e2928ab3a004856b7125 Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Wed, 15 Jan 2020 09:30:46 -0800 Subject: [PATCH 002/120] Adding pulsar input and reading pulsar parameters using Don's PR --- GNUmakefile | 1 + Source/Particles/Make.package | 1 + Source/Particles/PulsarParameters.H | 23 +++++++++++++++++++++++ Source/Particles/PulsarParameters.cpp | 27 +++++++++++++++++++++++++++ Source/WarpX.cpp | 9 ++++++++- 5 files changed, 60 insertions(+), 1 deletion(-) create mode 100644 Source/Particles/PulsarParameters.H create mode 100644 Source/Particles/PulsarParameters.cpp diff --git a/GNUmakefile b/GNUmakefile index 0842c069679..349c4be70d3 100644 --- a/GNUmakefile +++ b/GNUmakefile @@ -36,6 +36,7 @@ USE_ASCENT_INSITU = FALSE USE_OPENPMD = FALSE WarpxBinDir = Bin +PULSAR = TRUE USE_PSATD = FALSE USE_PSATD_PICSAR = FALSE diff --git a/Source/Particles/Make.package b/Source/Particles/Make.package index f25628e04e6..c4547e1c578 100644 --- a/Source/Particles/Make.package +++ b/Source/Particles/Make.package @@ -4,6 +4,7 @@ CEXE_sources += RigidInjectedParticleContainer.cpp CEXE_sources += PhysicalParticleContainer.cpp CEXE_sources += PhotonParticleContainer.cpp CEXE_sources += LaserParticleContainer.cpp +CEXE_sources += PulsarParameters.cpp include $(WARPX_HOME)/Source/Particles/Pusher/Make.package include $(WARPX_HOME)/Source/Particles/Deposition/Make.package diff --git a/Source/Particles/PulsarParameters.H b/Source/Particles/PulsarParameters.H new file mode 100644 index 00000000000..f450c1c55c5 --- /dev/null +++ b/Source/Particles/PulsarParameters.H @@ -0,0 +1,23 @@ +#ifndef PULSAR_PARAMETERS_H +#define PULSAR_PARAMETERS_H + +#include +#include +#include + +namespace PulsarParm +{ + extern std::string pulsar_type; + + extern AMREX_GPU_DEVICE_MANAGED amrex::Real omega_star; + extern AMREX_GPU_DEVICE_MANAGED amrex::Real B_star; + extern AMREX_GPU_DEVICE_MANAGED amrex::Real R_star; + extern AMREX_GPU_DEVICE_MANAGED amrex::Real dR_star; + + extern AMREX_GPU_DEVICE_MANAGED int verbose; + + void ReadParameters(); + +} + +#endif diff --git a/Source/Particles/PulsarParameters.cpp b/Source/Particles/PulsarParameters.cpp new file mode 100644 index 00000000000..197d50bad78 --- /dev/null +++ b/Source/Particles/PulsarParameters.cpp @@ -0,0 +1,27 @@ +#include +#include +#include + +namespace PulsarParm +{ + std::string pulsar_type; + + AMREX_GPU_DEVICE_MANAGED amrex::Real omega_star; + AMREX_GPU_DEVICE_MANAGED amrex::Real B_star; + AMREX_GPU_DEVICE_MANAGED amrex::Real R_star; + AMREX_GPU_DEVICE_MANAGED amrex::Real dR_star; + + AMREX_GPU_DEVICE_MANAGED int verbose = 0; + + void ReadParameters() { + amrex::ParmParse pp("pulsar"); + pp.query("pulsarType",pulsar_type); + pp.query("omega_star",omega_star); + pp.query("R_star",R_star); + pp.query("B_star",B_star); + pp.query("dR",dR_star); + pp.query("verbose",verbose); + } + + +} diff --git a/Source/WarpX.cpp b/Source/WarpX.cpp index 5794477d515..e78e8474d29 100644 --- a/Source/WarpX.cpp +++ b/Source/WarpX.cpp @@ -19,6 +19,9 @@ #include "Utils/WarpXUtil.H" #include "Utils/WarpXAlgorithmSelection.H" #include "Utils/WarpXProfilerWrapper.H" +#ifdef PULSAR +# include "Particles/PulsarParameters.H" +#endif #include #include @@ -26,7 +29,7 @@ # include #endif -#ifdef AMREX_USE_OMP +#ifdef _OPENMP # include #endif @@ -1020,6 +1023,10 @@ WarpX::ReadParameters () } } +#ifdef PULSAR + PulsarParm::ReadParameters(); +#endif + } void From efefcc2a17faa1b3d0a4b1e65189a02db6e5a5eb Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Wed, 15 Jan 2020 11:21:03 -0800 Subject: [PATCH 003/120] adding input file for pulsar --- .../Visualization-checkpoint.ipynb | 211 ++++++++++ .../pulsar/Visualization.ipynb | 394 ++++++++++++++++++ .../pulsar/inputs.corotating.3d.PM | 95 +++++ 3 files changed, 700 insertions(+) create mode 100644 Examples/Physics_applications/pulsar/.ipynb_checkpoints/Visualization-checkpoint.ipynb create mode 100644 Examples/Physics_applications/pulsar/Visualization.ipynb create mode 100644 Examples/Physics_applications/pulsar/inputs.corotating.3d.PM diff --git a/Examples/Physics_applications/pulsar/.ipynb_checkpoints/Visualization-checkpoint.ipynb b/Examples/Physics_applications/pulsar/.ipynb_checkpoints/Visualization-checkpoint.ipynb new file mode 100644 index 00000000000..c127d11819a --- /dev/null +++ b/Examples/Physics_applications/pulsar/.ipynb_checkpoints/Visualization-checkpoint.ipynb @@ -0,0 +1,211 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Overview\n", + "\n", + "This a notebook that inspects the results of a WarpX simulation.\n", + "\n", + "# Instruction\n", + "\n", + "Enter the path of the data you wish to visualize below. Then execute the cells one by one, by selecting them with your mouse and typing `Shift + Enter`" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Import statements\n", + "import yt ; yt.funcs.mylog.setLevel(50)\n", + "import numpy as np\n", + "import scipy.constants as scc\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib notebook" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Read data in the simulation frame" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot data with yt" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ds = yt.load( './plotfiles/plt00000/' ) # Create a dataset object\n", + "sl = yt.SlicePlot(ds, 2, 'Ex', aspect=1) # Create a sliceplot object\n", + "#sl.annotate_particles(width=(10.e-6, 'm'), p_size=2, ptype='beam', col='black')\n", + "#sl.annotate_grids() # Show grids\n", + "sl.show() # Show the plot\n", + "# sl.save('./toto.png')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Store quantities in numpy arrays, and plot with matplotlib" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Get field quantities\n", + "all_data_level_0 = ds.covering_grid(level=0,left_edge=ds.domain_left_edge, dims=ds.domain_dimensions)\n", + "Bx = all_data_level_0['boxlib', 'Ex'].v.squeeze()\n", + "Dx = ds.domain_width/ds.domain_dimensions\n", + "extent = [ds.domain_left_edge[ds.dimensionality-1], ds.domain_right_edge[ds.dimensionality-1],\n", + " ds.domain_left_edge[0], ds.domain_right_edge[0] ]\n", + "\n", + "# Get particle quantities\n", + "ad = ds.all_data()\n", + "x = ad['beam', 'particle_position_x'].v\n", + "z = ad['beam', 'particle_position_y'].v\n", + "\n", + "# Plot image\n", + "plt.figure()\n", + "plt.imshow(Bx, extent=extent)\n", + "plt.scatter(z,x,s=.1,c='k')\n", + "\n", + "# Print all available quantities\n", + "ds.field_list" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Read data back-transformed to the lab frame when the simulation runs in the boosted frame (example: 2D run)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# read_raw_data.py is located in warpx/Tools.\n", + "import os, glob\n", + "import read_raw_data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "species = 'beam'\n", + "iteration = 1\n", + "field = 'Ex'\n", + "\n", + "snapshot = './lab_frame_data/' + 'snapshot' + str(iteration).zfill(5)\n", + "header = './lab_frame_data/Header'\n", + "allrd, info = read_raw_data.read_lab_snapshot(snapshot, header) # Read field data\n", + "F = allrd[field]\n", + "print( \"Available info: \", *list(info.keys()) )\n", + "print(\"Available fields: \", info['field_names'])\n", + "nx = info['nx']\n", + "nz = info['nz']\n", + "x = info['x']\n", + "z = info['z']\n", + "xbo = read_raw_data.get_particle_field(snapshot, species, 'x') # Read particle data\n", + "ybo = read_raw_data.get_particle_field(snapshot, species, 'y')\n", + "zbo = read_raw_data.get_particle_field(snapshot, species, 'z')\n", + "uzbo = read_raw_data.get_particle_field(snapshot, species, 'uz')\n", + "\n", + "plt.figure(figsize=(6, 3))\n", + "extent = np.array([info['zmin'], info['zmax'], info['xmin'], info['xmax']])\n", + "plt.imshow(F, aspect='auto', extent=extent, cmap='seismic')\n", + "plt.colorbar()\n", + "plt.plot(zbo, xbo, 'g.', markersize=1.)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Read back-transformed data with hdf5 format (example: 3D run)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import h5py\n", + "import matplotlib.pyplot as plt\n", + "f = h5py.File('HDF5_lab_frame_data/snapshot00003', 'r')\n", + "print( list(f.keys()) )\n", + "# plt.figure()\n", + "plt.imshow(f['Ey'][:,,:])" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.2" + }, + "widgets": { + "state": { + "11d243e9f5074fe1b115949d174d59de": { + "views": [ + { + "cell_index": 6 + } + ] + } + }, + "version": "1.2.0" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Examples/Physics_applications/pulsar/Visualization.ipynb b/Examples/Physics_applications/pulsar/Visualization.ipynb new file mode 100644 index 00000000000..3815de927fd --- /dev/null +++ b/Examples/Physics_applications/pulsar/Visualization.ipynb @@ -0,0 +1,394 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Overview\n", + "\n", + "This a notebook that inspects the results of a WarpX simulation.\n", + "\n", + "# Instruction\n", + "\n", + "Enter the path of the data you wish to visualize below. Then execute the cells one by one, by selecting them with your mouse and typing `Shift + Enter`" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Import statements\n", + "import yt ; yt.funcs.mylog.setLevel(50)\n", + "import numpy as np\n", + "import scipy.constants as scc\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib notebook" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Read data in the simulation frame" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot data with yt" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[('all', 'particle_Bx'),\n", + " ('all', 'particle_By'),\n", + " ('all', 'particle_Bz'),\n", + " ('all', 'particle_Ex'),\n", + " ('all', 'particle_Ey'),\n", + " ('all', 'particle_Ez'),\n", + " ('all', 'particle_cpu'),\n", + " ('all', 'particle_id'),\n", + " ('all', 'particle_momentum_x'),\n", + " ('all', 'particle_momentum_y'),\n", + " ('all', 'particle_momentum_z'),\n", + " ('all', 'particle_position_x'),\n", + " ('all', 'particle_position_y'),\n", + " ('all', 'particle_position_z'),\n", + " ('all', 'particle_weight'),\n", + " ('boxlib', 'Bx'),\n", + " ('boxlib', 'By'),\n", + " ('boxlib', 'Bz'),\n", + " ('boxlib', 'Ex'),\n", + " ('boxlib', 'Ey'),\n", + " ('boxlib', 'Ez'),\n", + " ('boxlib', 'divE'),\n", + " ('boxlib', 'jx'),\n", + " ('boxlib', 'jy'),\n", + " ('boxlib', 'jz'),\n", + " ('boxlib', 'part_per_cell'),\n", + " ('boxlib', 'rho'),\n", + " ('plasma_e', 'particle_Bx'),\n", + " ('plasma_e', 'particle_By'),\n", + " ('plasma_e', 'particle_Bz'),\n", + " ('plasma_e', 'particle_Ex'),\n", + " ('plasma_e', 'particle_Ey'),\n", + " ('plasma_e', 'particle_Ez'),\n", + " ('plasma_e', 'particle_cpu'),\n", + " ('plasma_e', 'particle_id'),\n", + " ('plasma_e', 'particle_momentum_x'),\n", + " ('plasma_e', 'particle_momentum_y'),\n", + " ('plasma_e', 'particle_momentum_z'),\n", + " ('plasma_e', 'particle_position_x'),\n", + " ('plasma_e', 'particle_position_y'),\n", + " ('plasma_e', 'particle_position_z'),\n", + " ('plasma_e', 'particle_weight'),\n", + " ('plasma_p', 'particle_Bx'),\n", + " ('plasma_p', 'particle_By'),\n", + " ('plasma_p', 'particle_Bz'),\n", + " ('plasma_p', 'particle_Ex'),\n", + " ('plasma_p', 'particle_Ey'),\n", + " ('plasma_p', 'particle_Ez'),\n", + " ('plasma_p', 'particle_cpu'),\n", + " ('plasma_p', 'particle_id'),\n", + " ('plasma_p', 'particle_momentum_x'),\n", + " ('plasma_p', 'particle_momentum_y'),\n", + " ('plasma_p', 'particle_momentum_z'),\n", + " ('plasma_p', 'particle_position_x'),\n", + " ('plasma_p', 'particle_position_y'),\n", + " ('plasma_p', 'particle_position_z'),\n", + " ('plasma_p', 'particle_weight')]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds = yt.load( './plotfiles/plt00075/' ) # Create a dataset object\n", + "ds.field_list" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "sl = yt.SlicePlot(ds, 2, 'Ez', aspect=1) # Create a sliceplot object\n", + "#sl.annotate_particles((10, 'Mpc'),ptype=\"plasma_p\",col='b',p_size=5.0)\n", + "#sl.annotate_particles((10, 'Mpc'),ptype=\"plasma_e\",col='r',p_size=5.0)\n", + "#sl.annotate_particles(width=(10.e-6, 'm'), p_size=2, ptype='beam', col='black')\n", + "#sl.annotate_grids() # Show grids\n", + "sl.show() # Show the plot\n", + "# sl.save('./toto.png')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Store quantities in numpy arrays, and plot with matplotlib" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.5/dist-packages/matplotlib/colors.py:1028: RuntimeWarning: invalid value encountered in less_equal\n", + " mask |= resdat <= 0\n" + ] + }, + { + "data": { + "text/html": [ + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.5/dist-packages/matplotlib/colors.py:1028: RuntimeWarning: invalid value encountered in less_equal\n", + " mask |= resdat <= 0\n" + ] + }, + { + "data": { + "text/plain": [ + "['uniform_ring_50ppc.png']" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p = yt.ParticlePlot(ds,('plasma_p', 'particle_position_x'),('plasma_p', 'particle_position_y'),('plasma_p', 'particle_weight'))\n", + "\n", + "p.show()\n", + "p.save(\"uniform_ring_50ppc.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.5/dist-packages/matplotlib/colors.py:1028: RuntimeWarning: invalid value encountered in less_equal\n", + " mask |= resdat <= 0\n" + ] + }, + { + "data": { + "text/html": [ + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.5/dist-packages/matplotlib/colors.py:1028: RuntimeWarning: invalid value encountered in less_equal\n", + " mask |= resdat <= 0\n" + ] + }, + { + "data": { + "text/plain": [ + "['uniform_ring_50ppc.png']" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p = yt.ParticlePlot(ds,('plasma_e', 'particle_position_x'),('plasma_e', 'particle_position_y'),('plasma_e', 'particle_weight'))\n", + "\n", + "p.show()\n", + "p.save(\"uniform_ring_50ppc.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "# Get field quantities\n", + "all_data_level_0 = ds.covering_grid(level=0,left_edge=ds.domain_left_edge, dims=ds.domain_dimensions)\n", + "Bx = all_data_level_0['boxlib', 'Ex'].v.squeeze()\n", + "Dx = ds.domain_width/ds.domain_dimensions\n", + "extent = [ds.domain_left_edge[ds.dimensionality-1], ds.domain_right_edge[ds.dimensionality-1],\n", + " ds.domain_left_edge[0], ds.domain_right_edge[0] ]\n", + "\n", + "# Get particle quantities\n", + "ad = ds.all_data()\n", + "x = ad['beam', 'particle_position_x'].v\n", + "z = ad['beam', 'particle_position_y'].v\n", + "\n", + "# Plot image\n", + "plt.figure()\n", + "plt.imshow(Bx, extent=extent)\n", + "plt.scatter(z,x,s=.1,c='k')\n", + "\n", + "# Print all available quantities\n", + "ds.field_list" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Read data back-transformed to the lab frame when the simulation runs in the boosted frame (example: 2D run)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# read_raw_data.py is located in warpx/Tools.\n", + "import os, glob\n", + "import read_raw_data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "species = 'beam'\n", + "iteration = 1\n", + "field = 'Ex'\n", + "\n", + "snapshot = './lab_frame_data/' + 'snapshot' + str(iteration).zfill(5)\n", + "header = './lab_frame_data/Header'\n", + "allrd, info = read_raw_data.read_lab_snapshot(snapshot, header) # Read field data\n", + "F = allrd[field]\n", + "print( \"Available info: \", *list(info.keys()) )\n", + "print(\"Available fields: \", info['field_names'])\n", + "nx = info['nx']\n", + "nz = info['nz']\n", + "x = info['x']\n", + "z = info['z']\n", + "xbo = read_raw_data.get_particle_field(snapshot, species, 'x') # Read particle data\n", + "ybo = read_raw_data.get_particle_field(snapshot, species, 'y')\n", + "zbo = read_raw_data.get_particle_field(snapshot, species, 'z')\n", + "uzbo = read_raw_data.get_particle_field(snapshot, species, 'uz')\n", + "\n", + "plt.figure(figsize=(6, 3))\n", + "extent = np.array([info['zmin'], info['zmax'], info['xmin'], info['xmax']])\n", + "plt.imshow(F, aspect='auto', extent=extent, cmap='seismic')\n", + "plt.colorbar()\n", + "plt.plot(zbo, xbo, 'g.', markersize=1.)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Read back-transformed data with hdf5 format (example: 3D run)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import h5py\n", + "import matplotlib.pyplot as plt\n", + "f = h5py.File('HDF5_lab_frame_data/snapshot00003', 'r')\n", + "print( list(f.keys()) )\n", + "# plt.figure()\n", + "plt.imshow(f['Ey'][:,,:])" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.2" + }, + "widgets": { + "state": { + "11d243e9f5074fe1b115949d174d59de": { + "views": [ + { + "cell_index": 6 + } + ] + } + }, + "version": "1.2.0" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM new file mode 100644 index 00000000000..4b618ced95f --- /dev/null +++ b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM @@ -0,0 +1,95 @@ +# Description: +# +# This inputs file sets up a NS with these properties: +# - E = -(omega*R)[cross]B inside the NS +# - external E and B outside the star +# +# See the "Pulsar Setup" section at the end for the options +# +# This initializes the electrons and positrons with a corotating momentum function. +# Based on the pulsar_type = "active" or "dead", particles are injected continuously or +# until rho_GJ is reached + +################################# +####### GENERAL PARAMETERS ###### +################################# +max_step = 5000 +#amr.n_cell = 256 256 256 +amr.n_cell = 128 128 128 +amr.max_grid_size = 64 +amr.blocking_factor = 64 +amr.max_level = 0 +amr.plot_file = "plotfiles/plt" +amr.plot_int = 25 +geometry.coord_sys = 0 # 0: Cartesian +geometry.is_periodic = 0 0 0 # Is periodic? +geometry.prob_lo = 0.0 0.0 0.0 +geometry.prob_hi = 180000 180000 180000 + +################################# +############ NUMERICS ########### +################################# +algo.maxwell_fdtd_solver = yee +warpx.verbose = 1 +warpx.plot_raw_fields = 0 +warpx.do_dive_cleaning = 0 +warpx.use_filter = 1 +warpx.cfl = .99 +warpx.fields_to_plot = Ex Ey Ez Bx By Bz jx jy jz part_per_cell rho divE +my_constants.pi = 3.141592653589793 +my_constants.dens = 5.544e6 +my_constants.xc = 90000 +my_constants.yc = 90000 +my_constants.zc = 90000 +my_constants.r_star = 12000 +my_constants.omega = 6245.676 +my_constants.c = 299792458. +my_constants.B_star = 8.0323e-6 # magnetic field of NS (T) +my_constants.dR = 2e3 +interpolation.nox = 3 +interpolation.noy = 3 +interpolation.noz = 3 + + +################################# +############ PLASMA ############# +################################# +particles.nspecies = 2 +particles.species_names = plasma_e plasma_p + +plasma_e.charge = -q_e +plasma_e.mass = m_e +plasma_e.injection_style = "NUniformPerCell" +plasma_e.profile = parse_density_function +plasma_e.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))(r_star-dR)) )*dens" +plasma_e.num_particles_per_cell_each_dim = 3 3 3 +plasma_e.momentum_distribution_type = parse_momentum_function +plasma_e.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5)) Date: Wed, 15 Jan 2020 11:26:50 -0800 Subject: [PATCH 004/120] whitespace style fix --- Examples/Physics_applications/pulsar/inputs.corotating.3d.PM | 2 +- Source/Particles/PulsarParameters.cpp | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM index 4b618ced95f..e1fb74bd3f8 100644 --- a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM +++ b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM @@ -7,7 +7,7 @@ # See the "Pulsar Setup" section at the end for the options # # This initializes the electrons and positrons with a corotating momentum function. -# Based on the pulsar_type = "active" or "dead", particles are injected continuously or +# Based on the pulsar_type = "active" or "dead", particles are injected continuously or # until rho_GJ is reached ################################# diff --git a/Source/Particles/PulsarParameters.cpp b/Source/Particles/PulsarParameters.cpp index 197d50bad78..a97cf875941 100644 --- a/Source/Particles/PulsarParameters.cpp +++ b/Source/Particles/PulsarParameters.cpp @@ -22,6 +22,6 @@ namespace PulsarParm pp.query("dR",dR_star); pp.query("verbose",verbose); } - - + + } From c28bf7cd1906280ca69842797d1158dffa69d526 Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Wed, 15 Jan 2020 11:30:49 -0800 Subject: [PATCH 005/120] moved vis from pulsar file to tools --- .../Visualization.ipynb => Tools/Visualization_pulsar.ipynb | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Examples/Physics_applications/pulsar/Visualization.ipynb => Tools/Visualization_pulsar.ipynb (100%) diff --git a/Examples/Physics_applications/pulsar/Visualization.ipynb b/Tools/Visualization_pulsar.ipynb similarity index 100% rename from Examples/Physics_applications/pulsar/Visualization.ipynb rename to Tools/Visualization_pulsar.ipynb From 556430ff77e374e92704d3b03efe55eb50c0db24 Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Wed, 15 Jan 2020 11:32:13 -0800 Subject: [PATCH 006/120] scaling notebook to detemine inputs for pulsar --- Tools/Pulsar_scale_RstarPhysical.ipynb | 706 +++++++++++++++++++++++++ 1 file changed, 706 insertions(+) create mode 100644 Tools/Pulsar_scale_RstarPhysical.ipynb diff --git a/Tools/Pulsar_scale_RstarPhysical.ipynb b/Tools/Pulsar_scale_RstarPhysical.ipynb new file mode 100644 index 00000000000..d3afd8bed75 --- /dev/null +++ b/Tools/Pulsar_scale_RstarPhysical.ipynb @@ -0,0 +1,706 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Overview\n", + "\n", + "This a notebook that inspects the results of a WarpX simulation.\n", + "\n", + "# Instruction\n", + "\n", + "Enter the path of the data you wish to visualize below. Then execute the cells one by one, by selecting them with your mouse and typing `Shift + Enter`" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Import statements\n", + "import yt ; yt.funcs.mylog.setLevel(50)\n", + "import numpy as np\n", + "import scipy.constants as scc\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib notebook" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#Define the Physical Constants, normalizations, and the scale-down parameter, r_scale, for the pulsar. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "######################\n", + "# physical constants #\n", + "######################\n", + "c = 299792458.0 # speed of light \n", + "q_e = 1.602176634e-19 # elementary charge\n", + "me=9.10938356*np.power(10.,-31) # electron mass\n", + "epsilon=8.8541878128*np.power(10.,-12) # permittivity of free space\n", + "mu_o = 4*3.14*1e-7 # permeability\n", + "pi = 3.14159265358979323846\n", + "SolarMass = 2e30\n", + "G = 6.674e-11 # gravitational constant\n", + "\n", + "#############################################################################\n", + "# Parameters for a real Pulsar #\n", + "# (Table 7 of J.Petri's article on Theory of Pulsar Magnetosphere and Wind) #\n", + "#############################################################################\n", + "Omega_real = 6283\n", + "B_real = 7.4E4\n", + "R_real = 12000\n", + "n_real = 6.9e16\n", + "omega_pe_real = (n_real*q_e*q_e/(me*epsilon))**0.5 #plasma frequency\n", + "SkinDepth_real = c/omega_pe_real \n", + "Mstar = 1.4*SolarMass\n", + "Rstar_skinDepth_real = 6e5\n", + "\n", + "##################\n", + "# Normalizations #\n", + "##################\n", + "Rstar_skinDepth = 6e0 # Ratio of radius of star to the skin Depth \n", + " # For a real star, this ratio is 6e5\n", + "exponent = np.arange(0,6,1) \n", + "Factor = np.array(10**exponent)\n", + "Rstar_skinDepth = np.array(6*Factor) \n", + "\n", + "RLC_Rstar = 4 # Ratio of light cylinder (where the particle speed ~ c) to Rstar\n", + " # For a pulsar with 1ms period, this ratio is 4. \n", + " # i.e., This ratio sets the omega value, since Omega*RLC = c\n", + "\n", + "# Choose skindepth as the free parameter for a choice of normalizations given above\n", + "# The skin depth below is computed from the number density for a real pulsar\n", + "# Keeping the SkinDepth constant across all the scales in our scaling study\n", + "#SkinDepth = 0.02\n", + "\n", + "# Since skin depth is maintained across the scales, and RLC/Rstar is also maintained \n", + "# lets define the decrease in the scale by comparing the value of \n", + "# (Rstar/skinDepth)/(Rstar_real/skinDepth_real)\n", + "#r_scale = Rstar_skinDepth/Rstar_skinDepth_real\n", + "\n", + "Rstar = np.ones(6)*12000\n", + "SkinDepth = Rstar/Rstar_skinDepth\n", + "r_scale = Rstar_skinDepth_real/Rstar_skinDepth" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "##################################################################\n", + "# Derive other physical parameters from the above normalizations #\n", + "##################################################################\n", + "\n", + "# 1. Lorentz Boost (dimensionless) #\n", + "# Note that in Alex Chen's paper, gamma_o ~ (1/4)*normalized_values.\n", + "# Instead here we have pi/2, since that leads to the closes gamma_o \n", + "# value for a real 1ms pulsar. \n", + "gamma_o = (pi/2)*(Rstar_skinDepth)**2/RLC_Rstar \n", + "\n", + "\n", + "gamma_real = (pi/2)*6e5**2/RLC_Rstar;\n", + "gamma_scaling = gamma_o/(gamma_real) # This is to see how the gamma value \n", + " # decreases due to decrease in the ratio of R_star to skin depth\n", + "\n", + "\n", + "\n", + "# 3. Light cylinder location (m)\n", + "RLC = Rstar*RLC_Rstar\n", + "# 4. Angular Frequency (rad/s)\n", + "# Omega remains constant\n", + "Omega = c/RLC\n", + "# 5. Period (s)\n", + "# Period remains constant\n", + "Period = 2*3.14/Omega\n", + "# Moment of inertia for a sphere = (2/5)MR^2 (kg.m^2)\n", + "# Note that when the Rstar is scaled by r_scale, \n", + "# Mstar decreases as r_scale^3. Thus Mstar*r_scale**3 is the \n", + "# mass of the scaled down star.\n", + "# I remains constant across all scales\n", + "I = (2/5)*(Mstar)*Rstar**2\n", + "# 6. Rotation induced potential drop from pote to equator (V)\n", + "# Reference: Alex Chen's 2014 paper\n", + "# Scales as 1/r_scale**2\n", + "phi_o = gamma_o * (me/q_e) * c**2\n", + "\n", + "# Braking is the rate of slow-down of the spin. \n", + "# It is not relevant for the scaling. \n", + "# However, 1e-15 is the P_dot for a pulsar with P=1s\n", + "# and the rate of slowdown decreases proportional to the period. \n", + "# So we were to compare two stars with same radius, but different Omega\n", + "# then we can use Braking to determine the magnetic field strength at the surface as follows\n", + "# Bo = (3*mu_o*c*c*c/(32*pi*pi*pi))**0.5 * (I*Braking*Period)**0.5/(Rstar**3) \n", + "# (Reference : Table 7 of Jetri's article)\n", + "# Remains constant across all scales\n", + "Braking = 1e-15*Period\n", + "\n", + "# 7. Magnetic field strength (Tesla)\n", + "# Bo decreases as ~ 1/r_scale**2\n", + "Bo = phi_o/(Rstar*Rstar*Omega)\n", + "\n", + "# 8. Volume charge density (C/m^3) for uniform magnetization insize the star \n", + "# Refer to Table 7 of Petri's article \n", + "# Since Omega increases as r_scale and Bo decreases as r_scale\n", + "# The product of Omega*Bo remains constant across all scales. \n", + "# Thus, rho_e decreases as (1/r_scale**2)\n", + "rho_e = 2*epsilon*Omega*Bo #(Not adding the negative sign here)\n", + "\n", + "# 9. Electron number density (#/m^3)\n", + "# ne decreases as (1/r_scale**2)\n", + "ne = rho_e/q_e\n", + "# 9a. plasma frequency \n", + "# decreases as (1/r_scale)\n", + "omega_pe = (ne*q_e*q_e/(me*epsilon))**0.5 #plasma frequency\n", + "# 10. Magnetic moment (Am^2)\n", + "# decreases as (1/r_scale**2)\n", + "magnetic_moment = Bo*Rstar*Rstar*Rstar*4*pi/(mu_o)\n", + "# 11. E-field (V/m)\n", + "# Efield decreases as (1/r_scale**2)\n", + "E = Omega*Bo*Rstar\n", + "\n", + "\n", + "#########################################\n", + "# How do the energies and forces scale? #\n", + "#########################################\n", + "# 12. Magnetic Energy (J)\n", + "# Magnetic energy decreases as (1/r_scale**4)\n", + "magnetic_energy = (4*pi/3)*Bo**2*Rstar**3/(2*mu_o)\n", + "\n", + "# 13. Gravitational Potential Energy (J)\n", + "# G.pot energy remains constant \n", + "GP_energy = (3/5)*G*Mstar*Mstar/(Rstar)\n", + "\n", + "# 14. Gravitational to Electric force (dimensionless)\n", + "# This ratio increases as r_scale**2\n", + "G_EForce = G*Mstar*me/(Rstar*Rstar*q_e*E)\n", + "\n", + "# 15. Rotational kinetic energy \n", + "# Rot. KE remains constant\n", + "rotational_KE = (1/2)*I*Omega**2\n", + "\n", + "# 16. From (12) and (13), we know the B.energy scales as (1/r_scale**4) and GP energy is constant \n", + "# Thus the ratio of GP_energy and B_energy increases as r_scale**4\n", + "GB_energy_ratio = GP_energy/magnetic_energy\n", + "\n", + "# 17. Rate of change of Omega, or angular acceleration decreases as 1/r_scale**4\n", + "Omega_dot = Bo*Bo*Rstar**6*Omega**3/(I) * (32*pi/(3*mu_o*c**3))* (1/(4*pi*pi))\n", + "\n", + "# 18. Torque decreases as 1/r_scale**4\n", + "Torque = I * Omega_dot\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Input parameters for WarpX for geometry scaled down by r_scale = [1.e-05 1.e-04 1.e-03 1.e-02 1.e-01 1.e+00]\n", + "Lorentz factor, (gamma_o) = [1.41371669e+01 1.41371669e+03 1.41371669e+05 1.41371669e+07\n", + " 1.41371669e+09 1.41371669e+11]\n", + "Rstar (m) [12000. 12000. 12000. 12000. 12000. 12000.]\n", + "Omega (rad/s) [6245.67620833 6245.67620833 6245.67620833 6245.67620833 6245.67620833\n", + " 6245.67620833]\n", + "Bo (Tesla) [8.03230942e-06 8.03230942e-04 8.03230942e-02 8.03230942e+00\n", + " 8.03230942e+02 8.03230942e+04]\n", + "ne (/m^3) [5.54482989e+06 5.54482989e+08 5.54482989e+10 5.54482989e+12\n", + " 5.54482989e+14 5.54482989e+16]\n", + "Size of the domain, (m) [360000. 360000. 360000. 360000. 360000. 360000.]\n", + "Minimum cell size (m) [2.e+03 2.e+02 2.e+01 2.e+00 2.e-01 2.e-02]\n", + "timestep (s) [3.76386776e-06 3.76386776e-07 3.76386776e-08 3.76386776e-09\n", + " 3.76386776e-10 3.76386776e-11]\n", + "Numver of cells assuming unif. grid, [1.8e+02 1.8e+03 1.8e+04 1.8e+05 1.8e+06 1.8e+07]\n" + ] + } + ], + "source": [ + "############################################################\n", + "# Print all the values that will be used as input in WarpX #\n", + "############################################################\n", + "print(\"Input parameters for WarpX for geometry scaled down by r_scale = \", Rstar_skinDepth/Rstar_skinDepth_real)\n", + "print(\"Lorentz factor, (gamma_o) = \", gamma_o)\n", + "print(\"Rstar (m)\", Rstar)\n", + "print(\"Omega (rad/s)\", Omega)\n", + "print(\"Bo (Tesla)\", Bo)\n", + "print(\"ne (/m^3)\", ne)\n", + "print(\"Size of the domain, (m)\", 30*Rstar)\n", + "print(\"Minimum cell size (m)\", SkinDepth)\n", + "print(\"timestep (s)\", 0.5*omega_pe**-1) # Or may be cfl criterion\n", + "print(\"Numver of cells assuming unif. grid, \", 30*Rstar/SkinDepth)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gravitational force to E-force : [1.22562947e-02 1.22562947e-04 1.22562947e-06 1.22562947e-08\n", + " 1.22562947e-10 1.22562947e-12]\n", + "Gravitational energy to B-energy : [1.40727411e+38 1.40727411e+34 1.40727411e+30 1.40727411e+26\n", + " 1.40727411e+22 1.40727411e+18]\n", + "B energy, (J) [1.85906071e+08 1.85906071e+12 1.85906071e+16 1.85906071e+20\n", + " 1.85906071e+24 1.85906071e+28]\n", + "Gravitational potential energy, (J) [2.616208e+46 2.616208e+46 2.616208e+46 2.616208e+46 2.616208e+46\n", + " 2.616208e+46]\n", + "Rotational Kinetic Energy (J) [3.14564313e+45 3.14564313e+45 3.14564313e+45 3.14564313e+45\n", + " 3.14564313e+45 3.14564313e+45]\n" + ] + } + ], + "source": [ + "#############################################################\n", + "# Print ratios of G.Pot.Energy/B_energy and G.Force/E_force #\n", + "#############################################################\n", + "print(\"Gravitational force to E-force : \", G_EForce)\n", + "print(\"Gravitational energy to B-energy : \",GB_energy_ratio)\n", + "\n", + "\n", + "# Print dimensional values of energies\n", + "print(\"B energy, (J)\",magnetic_energy);\n", + "print(\"Gravitational potential energy, (J)\", GP_energy)\n", + "print(\"Rotational Kinetic Energy (J)\", rotational_KE )\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plot Gravitational force to electric force -- should be constant across all scales\n", + "\n", + "plt.plot(Rstar_skinDepth/6e5,G_EForce,'ro')\n", + "plt.xlabel(\"Log( Normalized (Rstar/Lambda) ) Scaling\")\n", + "plt.ylabel(\"G.Force/E.Force\")\n", + "plt.xscale(\"log\")\n", + "plt.yscale(\"log\")\n", + "plt.savefig(\"G_Eforce_scaling.png\",bbox_inches='tight')\n", + "#plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plot Gravitational to magnetic energy -- should be constant across all scales\n", + "\n", + "plt.plot(Rstar_skinDepth/6e5,GB_energy_ratio,'ro')\n", + "plt.rcParams.update({'font.size': 18, 'font.family': 'serif'})\n", + "plt.xlabel(\"Log( Normalized (Rstar/Lambda) ) Scaling\")\n", + "plt.ylabel(\"G.Energy/B.energy\")\n", + "plt.xscale(\"log\")\n", + "plt.yscale(\"log\")\n", + "plt.savefig(\"G_Benergy_scaling.png\",bbox_inches='tight')\n", + "#plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Trends of all energies\n", + "plt.plot(Rstar_skinDepth/6e5,magnetic_energy,color=\"red\",ls='--',lw=2,marker=\"^\",markersize=8)\n", + "plt.plot(Rstar_skinDepth/6e5,GP_energy,color=\"blue\",lw=2,marker='o',markersize=8,markerfacecolor='blue')\n", + "plt.plot(Rstar_skinDepth/6e5,rotational_KE,color=\"purple\",lw=2,marker='s',markersize=8,markeredgecolor='purple')\n", + "plt.plot(Rstar_skinDepth/6e5,Torque,color=\"cyan\",lw=2,marker='>',markersize=8,markeredgecolor='purple')\n", + "plt.rcParams.update({'font.size': 18, 'font.family': 'serif'})\n", + "plt.xlabel(\"Log( Normalized (Rstar/Lambda) ) Scaling\")\n", + "plt.ylabel(\"Energy (J)\")\n", + "plt.xscale(\"log\")\n", + "plt.yscale(\"log\")\n", + "plt.rcParams.update({'font.size': 18, 'font.family': 'serif'})\n", + "plt.legend([\"Magnetic\",\"G. Potential\",\"Rotational KE\",\"Torque\"],loc=2,fontsize='small',frameon=\"false\",borderpad=0.1)\n", + "plt.ylim([1e0,1e90])\n", + "plt.savefig(\"Energy_scaling.png\",bbox_inches='tight')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plot Gravitational to magnetic energy -- should be constant across all scales\n", + "plt.plot(Rstar_skinDepth/6e5,Bo/Bo[5],color=\"blue\",lw=2,marker='s',markersize=8)\n", + "plt.ylabel(\"Normalized B. field\",color=\"blue\")\n", + "plt.xlabel(\"Log( Normalized (Rstar/Lambda) ) Scaling\")\n", + "plt.yticks(color=\"blue\")\n", + "plt.xscale(\"log\")\n", + "plt.yscale(\"log\")\n", + "plt.twinx()\n", + "plt.plot(Rstar_skinDepth/6e5,Omega/Omega[5],color=\"red\",lw=2,marker='o',markersize=8)\n", + "plt.ylabel(\"Normalized \\u03A9\",color=\"red\")\n", + "plt.yticks(color=\"red\")\n", + "plt.xscale(\"log\")\n", + "plt.ylim([0,2])\n", + "plt.savefig(\"Normalized_B_Omega.png\",bbox_inches='tight')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(Rstar_skinDepth/6e5,gamma_o,'ro')\n", + "plt.rcParams.update({'font.size': 18, 'font.family': 'serif'})\n", + "plt.xlabel(\"Log( Normalized (Rstar/Lambda) ) Scaling\")\n", + "plt.ylabel(\"Normalized G.Energy/B.energy\")\n", + "plt.xscale(\"log\")\n", + "plt.yscale(\"log\")\n", + "plt.savefig(\"G_Benergy_scaling.png\",bbox_inches='tight')\n", + "#plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(Rstar_skinDepth/6e5,Omega_dot,'ro')\n", + "plt.rcParams.update({'font.size': 18, 'font.family': 'serif'})\n", + "plt.xlabel(\"Log( Normalized (Rstar/Lambda) ) Scaling\")\n", + "plt.ylabel(\"Omega_dot\")\n", + "plt.xscale(\"log\")\n", + "plt.yscale(\"log\")\n", + "plt.savefig(\"G_Benergy_scaling.png\",bbox_inches='tight')\n", + "#plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(Rstar_skinDepth/6e5,Torque,'ro')\n", + "plt.rcParams.update({'font.size': 18, 'font.family': 'serif'})\n", + "plt.xlabel(\"Log( Normalized (Rstar/Lambda) ) Scaling\")\n", + "plt.ylabel(\"Torque\")\n", + "plt.xscale(\"log\")\n", + "plt.yscale(\"log\")\n", + "plt.savefig(\"Torque.png\",bbox_inches='tight')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(Rstar_skinDepth/6e5,phi_o,'ro')\n", + "plt.rcParams.update({'font.size': 18, 'font.family': 'serif'})\n", + "plt.xlabel(\"Log( Normalized (Rstar/Lambda) ) Scaling\")\n", + "plt.ylabel(\"Normalized G.Energy/B.energy\")\n", + "plt.xscale(\"log\")\n", + "plt.yscale(\"log\")\n", + "plt.savefig(\"phi_o.png\",bbox_inches='tight')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.020230407144897423" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "SkinDepth_real" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([48000., 48000., 48000., 48000., 48000., 48000.])" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "RLC\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "140.625" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "36000/256" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "particle_weight = 140.625**3*5.544e6/64" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "240896701812.74414" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "particle_weight" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.0010055, 0.0010055, 0.0010055, 0.0010055, 0.0010055, 0.0010055])" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Period" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([48000., 48000., 48000., 48000., 48000., 48000.])" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "RLC\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.2" + }, + "widgets": { + "state": { + "11d243e9f5074fe1b115949d174d59de": { + "views": [ + { + "cell_index": 6 + } + ] + } + }, + "version": "1.2.0" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} From 8f7a505e8f20f39a79e4c9fdc3e1ba1362c9359d Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Wed, 15 Jan 2020 11:36:40 -0800 Subject: [PATCH 007/120] removing unwanted file --- .../Visualization-checkpoint.ipynb | 211 ------------------ 1 file changed, 211 deletions(-) delete mode 100644 Examples/Physics_applications/pulsar/.ipynb_checkpoints/Visualization-checkpoint.ipynb diff --git a/Examples/Physics_applications/pulsar/.ipynb_checkpoints/Visualization-checkpoint.ipynb b/Examples/Physics_applications/pulsar/.ipynb_checkpoints/Visualization-checkpoint.ipynb deleted file mode 100644 index c127d11819a..00000000000 --- a/Examples/Physics_applications/pulsar/.ipynb_checkpoints/Visualization-checkpoint.ipynb +++ /dev/null @@ -1,211 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Overview\n", - "\n", - "This a notebook that inspects the results of a WarpX simulation.\n", - "\n", - "# Instruction\n", - "\n", - "Enter the path of the data you wish to visualize below. Then execute the cells one by one, by selecting them with your mouse and typing `Shift + Enter`" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# Import statements\n", - "import yt ; yt.funcs.mylog.setLevel(50)\n", - "import numpy as np\n", - "import scipy.constants as scc\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib notebook" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Read data in the simulation frame" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plot data with yt" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ds = yt.load( './plotfiles/plt00000/' ) # Create a dataset object\n", - "sl = yt.SlicePlot(ds, 2, 'Ex', aspect=1) # Create a sliceplot object\n", - "#sl.annotate_particles(width=(10.e-6, 'm'), p_size=2, ptype='beam', col='black')\n", - "#sl.annotate_grids() # Show grids\n", - "sl.show() # Show the plot\n", - "# sl.save('./toto.png')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Store quantities in numpy arrays, and plot with matplotlib" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Get field quantities\n", - "all_data_level_0 = ds.covering_grid(level=0,left_edge=ds.domain_left_edge, dims=ds.domain_dimensions)\n", - "Bx = all_data_level_0['boxlib', 'Ex'].v.squeeze()\n", - "Dx = ds.domain_width/ds.domain_dimensions\n", - "extent = [ds.domain_left_edge[ds.dimensionality-1], ds.domain_right_edge[ds.dimensionality-1],\n", - " ds.domain_left_edge[0], ds.domain_right_edge[0] ]\n", - "\n", - "# Get particle quantities\n", - "ad = ds.all_data()\n", - "x = ad['beam', 'particle_position_x'].v\n", - "z = ad['beam', 'particle_position_y'].v\n", - "\n", - "# Plot image\n", - "plt.figure()\n", - "plt.imshow(Bx, extent=extent)\n", - "plt.scatter(z,x,s=.1,c='k')\n", - "\n", - "# Print all available quantities\n", - "ds.field_list" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Read data back-transformed to the lab frame when the simulation runs in the boosted frame (example: 2D run)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# read_raw_data.py is located in warpx/Tools.\n", - "import os, glob\n", - "import read_raw_data" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "species = 'beam'\n", - "iteration = 1\n", - "field = 'Ex'\n", - "\n", - "snapshot = './lab_frame_data/' + 'snapshot' + str(iteration).zfill(5)\n", - "header = './lab_frame_data/Header'\n", - "allrd, info = read_raw_data.read_lab_snapshot(snapshot, header) # Read field data\n", - "F = allrd[field]\n", - "print( \"Available info: \", *list(info.keys()) )\n", - "print(\"Available fields: \", info['field_names'])\n", - "nx = info['nx']\n", - "nz = info['nz']\n", - "x = info['x']\n", - "z = info['z']\n", - "xbo = read_raw_data.get_particle_field(snapshot, species, 'x') # Read particle data\n", - "ybo = read_raw_data.get_particle_field(snapshot, species, 'y')\n", - "zbo = read_raw_data.get_particle_field(snapshot, species, 'z')\n", - "uzbo = read_raw_data.get_particle_field(snapshot, species, 'uz')\n", - "\n", - "plt.figure(figsize=(6, 3))\n", - "extent = np.array([info['zmin'], info['zmax'], info['xmin'], info['xmax']])\n", - "plt.imshow(F, aspect='auto', extent=extent, cmap='seismic')\n", - "plt.colorbar()\n", - "plt.plot(zbo, xbo, 'g.', markersize=1.)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Read back-transformed data with hdf5 format (example: 3D run)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import h5py\n", - "import matplotlib.pyplot as plt\n", - "f = h5py.File('HDF5_lab_frame_data/snapshot00003', 'r')\n", - "print( list(f.keys()) )\n", - "# plt.figure()\n", - "plt.imshow(f['Ey'][:,,:])" - ] - } - ], - "metadata": { - "anaconda-cloud": {}, - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.5.2" - }, - "widgets": { - "state": { - "11d243e9f5074fe1b115949d174d59de": { - "views": [ - { - "cell_index": 6 - } - ] - } - }, - "version": "1.2.0" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} From 082ea436dc9396e6456a8fc53dc56f82487edd24 Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Thu, 16 Jan 2020 20:52:24 -0800 Subject: [PATCH 008/120] added external E and B fields and the appropriate input parameters --- .../pulsar/inputs.corotating.3d.PM | 7 +- Source/Particles/MultiParticleContainer.H | 5 ++ Source/Particles/MultiParticleContainer.cpp | 10 +++ .../Particles/PhysicalParticleContainer.cpp | 22 +++++++ Source/Particles/PulsarParameters.H | 7 ++ Source/Particles/PulsarParameters.cpp | 66 ++++++++++++++++++- 6 files changed, 114 insertions(+), 3 deletions(-) diff --git a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM index e1fb74bd3f8..8d76089804c 100644 --- a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM +++ b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM @@ -61,7 +61,7 @@ plasma_e.charge = -q_e plasma_e.mass = m_e plasma_e.injection_style = "NUniformPerCell" plasma_e.profile = parse_density_function -plasma_e.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))(r_star-dR)) )*dens" +plasma_e.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star) * ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<(r_star+dR)) )*dens" plasma_e.num_particles_per_cell_each_dim = 3 3 3 plasma_e.momentum_distribution_type = parse_momentum_function plasma_e.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5)) #include @@ -932,6 +933,27 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) } }); +#ifdef PULSAR + if (PulsarParm::EB_external == 1) { + Real* const AMREX_RESTRICT xp_data = xp.dataPtr(); + Real* const AMREX_RESTRICT yp_data = yp.dataPtr(); + Real* const AMREX_RESTRICT zp_data = zp.dataPtr(); + Real* const AMREX_RESTRICT Exp_data = Exp.dataPtr(); + Real* const AMREX_RESTRICT Eyp_data = Eyp.dataPtr(); + Real* const AMREX_RESTRICT Ezp_data = Ezp.dataPtr(); + Real* const AMREX_RESTRICT Bxp_data = Bxp.dataPtr(); + Real* const AMREX_RESTRICT Byp_data = Byp.dataPtr(); + Real* const AMREX_RESTRICT Bzp_data = Bzp.dataPtr(); + Real time = warpx.gett_new(lev); + amrex::ParallelFor(pti.numParticles(), + [=] AMREX_GPU_DEVICE (long i) { + // spherical r, theta, phi, and cylidrical r + PulsarParm::PulsarEBField(xp_data[i],yp_data[i],zp_data[i], + Exp_data[i],Eyp_data[i],Ezp_data[i], + Bxp_data[i],Byp_data[i],Bzp_data[i],time); + }); + } +#endif amrex::Gpu::synchronize(); if (cost && WarpX::load_balance_costs_update_algo == LoadBalanceCostsUpdateAlgo::Timers) diff --git a/Source/Particles/PulsarParameters.H b/Source/Particles/PulsarParameters.H index f450c1c55c5..97741a71c69 100644 --- a/Source/Particles/PulsarParameters.H +++ b/Source/Particles/PulsarParameters.H @@ -13,10 +13,17 @@ namespace PulsarParm extern AMREX_GPU_DEVICE_MANAGED amrex::Real B_star; extern AMREX_GPU_DEVICE_MANAGED amrex::Real R_star; extern AMREX_GPU_DEVICE_MANAGED amrex::Real dR_star; + extern AMREX_GPU_DEVICE_MANAGED int EB_external; + extern AMREX_GPU_DEVICE_MANAGED int E_external_monopole; + extern AMREX_GPU_DEVICE_MANAGED amrex::Vector center_star; extern AMREX_GPU_DEVICE_MANAGED int verbose; void ReadParameters(); + void PulsarEBField(amrex::Real xp, amrex::Real yp, amrex::Real zp, + amrex::Real Exp, amrex::Real Eyp, amrex::Real Ezp, + amrex::Real Bxp, amrex::Real Byp, amrex::Real Bzp, + amrex::Real time); } diff --git a/Source/Particles/PulsarParameters.cpp b/Source/Particles/PulsarParameters.cpp index a97cf875941..e643ed3c59b 100644 --- a/Source/Particles/PulsarParameters.cpp +++ b/Source/Particles/PulsarParameters.cpp @@ -1,6 +1,9 @@ #include #include #include +#include +#include +#include namespace PulsarParm { @@ -10,18 +13,79 @@ namespace PulsarParm AMREX_GPU_DEVICE_MANAGED amrex::Real B_star; AMREX_GPU_DEVICE_MANAGED amrex::Real R_star; AMREX_GPU_DEVICE_MANAGED amrex::Real dR_star; - + AMREX_GPU_DEVICE_MANAGED int EB_external = 0; + AMREX_GPU_DEVICE_MANAGED int E_external_monopole = 0; + AMREX_GPU_DEVICE_MANAGED amrex::Vector center_star(3,0.0); AMREX_GPU_DEVICE_MANAGED int verbose = 0; void ReadParameters() { amrex::ParmParse pp("pulsar"); pp.query("pulsarType",pulsar_type); pp.query("omega_star",omega_star); + pp.queryarr("center_star",center_star); pp.query("R_star",R_star); pp.query("B_star",B_star); pp.query("dR",dR_star); pp.query("verbose",verbose); + pp.query("EB_external",EB_external); + pp.query("E_external_monopole",E_external_monopole); + amrex::Print() << " Pulsar center: " << center_star[0] << " " << center_star[1] << " " << center_star[2] << "\n"; + amrex::Print() << " Pulsar omega: " << omega_star << "\n"; + amrex::Print() << " Pulsar B_star : " << B_star << "\n"; } + void PulsarEBField(amrex::Real xp, amrex::Real yp, amrex::Real zp, + amrex::Real Exp, amrex::Real Eyp, amrex::Real Ezp, + amrex::Real Bxp, amrex::Real Byp, amrex::Real Bzp, + amrex::Real time) { + // spherical r, theta, phi + const amrex::Real xc = center_star[0]; + const amrex::Real yc = center_star[1]; + const amrex::Real zc = center_star[2]; + const amrex::Real r = std::sqrt( (xp-xc)*(xp-xc) + (yp-yc)*(yp-yc) + (zp-zc)*(zp-zc) ); + const amrex::Real phi = std::atan2((yp-yc),(xp-xc)); + amrex::Real theta = 0.0; + if (r > 0) { + theta = std::acos((zp-zc)/r); + } + const amrex::Real c_theta = std::cos(theta); + const amrex::Real s_theta = std::sin(theta); + const amrex::Real c_phi = std::cos(phi); + const amrex::Real s_phi = std::sin(phi); + + // Inside star :: uniform B a,d E = - (omega X r) X B + if (r= R_star) { + amrex::Real r_ratio = R_star/r; + amrex::Real r3 = r_ratio*r_ratio*r_ratio; + amrex::Real Er = B_star*omega_star*R_star*r_ratio*r3*(1-3*c_theta*c_theta); + if (E_external_monopole == 1) { + Er += (4.0/3.0)*omega_star*B_star*R_star*r_ratio*r_ratio; + } + amrex::Real Etheta = (-1.0)*B_star*omega_star*R_star*r_ratio*r3*(2*s_theta*c_theta); + + Exp = Er*s_theta*c_phi + Etheta*c_theta*c_phi; + Eyp = Er*s_theta*s_phi + Etheta*c_theta*s_phi; + Ezp = Er*c_theta - Etheta*s_theta; + + amrex::Real Br = 2*B_star*r3*c_theta; + amrex::Real Btheta = B_star*r3*s_theta; + + Bxp = Br*s_theta*c_phi + Btheta*c_theta*c_phi; + Byp = Br*s_theta*s_phi + Btheta*c_theta*s_phi; + Bzp = Br*c_theta - Btheta*s_theta; + } + } } From f7f38f95659b828bc3df9b2ed49134d6e8aa01f4 Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Thu, 16 Jan 2020 20:57:29 -0800 Subject: [PATCH 009/120] EOL whitespace --- .../pulsar/inputs.corotating.3d.PM | 2 +- Source/Particles/MultiParticleContainer.cpp | 4 +- .../Particles/PhysicalParticleContainer.cpp | 38 +++++++++---------- Source/Particles/PulsarParameters.cpp | 8 ++-- 4 files changed, 26 insertions(+), 26 deletions(-) diff --git a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM index 8d76089804c..f7aa7fb7d22 100644 --- a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM +++ b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM @@ -95,4 +95,4 @@ pulsar.B_star = 8.0323e-6 # magnetic field of NS (T) pulsar.dR = 2e3 pulsar.verbose = 0 # [0/1]: turn on verbosity for debugging print statements pulsar.EB_external = 1 # [0/1]: to apply external E and B -pulsar.E_external_monopole = 1 # [0/1] +pulsar.E_external_monopole = 1 # [0/1] diff --git a/Source/Particles/MultiParticleContainer.cpp b/Source/Particles/MultiParticleContainer.cpp index e51c9cf7d4a..0059bbf17e4 100644 --- a/Source/Particles/MultiParticleContainer.cpp +++ b/Source/Particles/MultiParticleContainer.cpp @@ -115,13 +115,13 @@ MultiParticleContainer::ReadParameters () ::tolower); #ifdef PULSAR - // co-ordinate system used to specify external fields + // co-ordinate system used to specify external fields // is cartesian (default) or spherical // For pulsar it is easier to provide (r,theta,phi) components // and let the code do the conversion to cartesian pp.query("E_ext_particle_coord", m_E_ext_particle_coord); pp.query("B_ext_particle_coord", m_B_ext_particle_coord); -#endif +#endif // if the input string for B_external on particles is "constant" // then the values for the external B on particles must diff --git a/Source/Particles/PhysicalParticleContainer.cpp b/Source/Particles/PhysicalParticleContainer.cpp index c1eae2d7d11..576713ec7b0 100644 --- a/Source/Particles/PhysicalParticleContainer.cpp +++ b/Source/Particles/PhysicalParticleContainer.cpp @@ -934,25 +934,25 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) }); #ifdef PULSAR - if (PulsarParm::EB_external == 1) { - Real* const AMREX_RESTRICT xp_data = xp.dataPtr(); - Real* const AMREX_RESTRICT yp_data = yp.dataPtr(); - Real* const AMREX_RESTRICT zp_data = zp.dataPtr(); - Real* const AMREX_RESTRICT Exp_data = Exp.dataPtr(); - Real* const AMREX_RESTRICT Eyp_data = Eyp.dataPtr(); - Real* const AMREX_RESTRICT Ezp_data = Ezp.dataPtr(); - Real* const AMREX_RESTRICT Bxp_data = Bxp.dataPtr(); - Real* const AMREX_RESTRICT Byp_data = Byp.dataPtr(); - Real* const AMREX_RESTRICT Bzp_data = Bzp.dataPtr(); - Real time = warpx.gett_new(lev); - amrex::ParallelFor(pti.numParticles(), - [=] AMREX_GPU_DEVICE (long i) { - // spherical r, theta, phi, and cylidrical r - PulsarParm::PulsarEBField(xp_data[i],yp_data[i],zp_data[i], - Exp_data[i],Eyp_data[i],Ezp_data[i], - Bxp_data[i],Byp_data[i],Bzp_data[i],time); - }); - } + if (PulsarParm::EB_external == 1) { + Real* const AMREX_RESTRICT xp_data = xp.dataPtr(); + Real* const AMREX_RESTRICT yp_data = yp.dataPtr(); + Real* const AMREX_RESTRICT zp_data = zp.dataPtr(); + Real* const AMREX_RESTRICT Exp_data = Exp.dataPtr(); + Real* const AMREX_RESTRICT Eyp_data = Eyp.dataPtr(); + Real* const AMREX_RESTRICT Ezp_data = Ezp.dataPtr(); + Real* const AMREX_RESTRICT Bxp_data = Bxp.dataPtr(); + Real* const AMREX_RESTRICT Byp_data = Byp.dataPtr(); + Real* const AMREX_RESTRICT Bzp_data = Bzp.dataPtr(); + Real time = warpx.gett_new(lev); + amrex::ParallelFor(pti.numParticles(), + [=] AMREX_GPU_DEVICE (long i) { + // spherical r, theta, phi, and cylidrical r + PulsarParm::PulsarEBField(xp_data[i],yp_data[i],zp_data[i], + Exp_data[i],Eyp_data[i],Ezp_data[i], + Bxp_data[i],Byp_data[i],Bzp_data[i],time); + }); + } #endif amrex::Gpu::synchronize(); diff --git a/Source/Particles/PulsarParameters.cpp b/Source/Particles/PulsarParameters.cpp index e643ed3c59b..cf0784f9bd6 100644 --- a/Source/Particles/PulsarParameters.cpp +++ b/Source/Particles/PulsarParameters.cpp @@ -46,13 +46,13 @@ namespace PulsarParm const amrex::Real phi = std::atan2((yp-yc),(xp-xc)); amrex::Real theta = 0.0; if (r > 0) { - theta = std::acos((zp-zc)/r); + theta = std::acos((zp-zc)/r); } const amrex::Real c_theta = std::cos(theta); - const amrex::Real s_theta = std::sin(theta); + const amrex::Real s_theta = std::sin(theta); const amrex::Real c_phi = std::cos(phi); const amrex::Real s_phi = std::sin(phi); - + // Inside star :: uniform B a,d E = - (omega X r) X B if (r Date: Fri, 17 Jan 2020 12:39:12 -0800 Subject: [PATCH 010/120] seeting up bounds for pulsar surface --- .../pulsar/inputs.corotating.3d.PM | 12 +++-- GNUmakefile | 2 +- Source/Evolve/WarpXEvolve.cpp | 5 ++ Source/Initialization/InjectorPosition.H | 10 ++++ Source/Initialization/PlasmaInjector.H | 4 ++ Source/Initialization/PlasmaInjector.cpp | 7 +++ Source/Particles/MultiParticleContainer.H | 5 ++ Source/Particles/MultiParticleContainer.cpp | 11 ++++ Source/Particles/PhysicalParticleContainer.H | 4 ++ .../Particles/PhysicalParticleContainer.cpp | 51 ++++++++++++++++++- Source/Particles/WarpXParticleContainer.H | 3 ++ 11 files changed, 107 insertions(+), 7 deletions(-) diff --git a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM index f7aa7fb7d22..747bf9294d8 100644 --- a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM +++ b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM @@ -20,7 +20,7 @@ amr.max_grid_size = 64 amr.blocking_factor = 64 amr.max_level = 0 amr.plot_file = "plotfiles/plt" -amr.plot_int = 25 +amr.plot_int = 1 geometry.coord_sys = 0 # 0: Cartesian geometry.is_periodic = 0 0 0 # Is periodic? geometry.prob_lo = 0.0 0.0 0.0 @@ -61,7 +61,8 @@ plasma_e.charge = -q_e plasma_e.mass = m_e plasma_e.injection_style = "NUniformPerCell" plasma_e.profile = parse_density_function -plasma_e.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star) * ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<(r_star+dR)) )*dens" +#plasma_e.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star) * ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<(r_star+dR)) )*dens" +plasma_e.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star) )*dens" plasma_e.num_particles_per_cell_each_dim = 3 3 3 plasma_e.momentum_distribution_type = parse_momentum_function plasma_e.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))PulsarParticleInjection(); + mypc->Redistribute(); +#endif + mypc->ApplyBoundaryConditions(); // Electrostatic solver: particles can move by an arbitrary number of cells diff --git a/Source/Initialization/InjectorPosition.H b/Source/Initialization/InjectorPosition.H index 2854ec6f8ba..e24e629b1ab 100644 --- a/Source/Initialization/InjectorPosition.H +++ b/Source/Initialization/InjectorPosition.H @@ -132,6 +132,16 @@ struct InjectorPosition y < ymax and y >= ymin and z < zmax and z >= zmin); } + + // bool: whether position specified is withing pulsar injection region +#ifdef PULSAR + AMREX_GPU_HOST_DEVICE + bool + insidePulsarBounds (amrex::Real r, amrex::Real R_star, amrex::Real dR_star) const noexcept + { + return (r>=R_star and r<=(R_star+dR_star)); + } +#endif // bool: whether the region defined by lo and hi overaps with the plasma region AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE diff --git a/Source/Initialization/PlasmaInjector.H b/Source/Initialization/PlasmaInjector.H index ce4d3184242..e8d82b5ac3a 100644 --- a/Source/Initialization/PlasmaInjector.H +++ b/Source/Initialization/PlasmaInjector.H @@ -46,6 +46,10 @@ public: // bool: whether the point (x, y, z) is inside the plasma region bool insideBounds (amrex::Real x, amrex::Real y, amrex::Real z) const noexcept; +#ifdef PULSAR + bool insidePulsarBounds (amrex::Real r, amrex::Real R_star, + amrex::Real dR_star) const noexcept; +#endif // bool: whether the region defined by lo and hi overlaps with the plasma region bool overlapsWith (const amrex::XDim3& lo, const amrex::XDim3& hi) const noexcept; diff --git a/Source/Initialization/PlasmaInjector.cpp b/Source/Initialization/PlasmaInjector.cpp index e838cfcb4c1..632e425c978 100644 --- a/Source/Initialization/PlasmaInjector.cpp +++ b/Source/Initialization/PlasmaInjector.cpp @@ -548,6 +548,13 @@ bool PlasmaInjector::insideBounds (Real x, Real y, Real z) const noexcept z < zmax and z >= zmin); } +#ifdef PULSAR +bool PlasmaInjector::insidePulsarBounds (Real r, Real R_star, Real dR_star) const noexcept +{ + return (r >= R_star and r <= R_star + dR_star); +} +#endif + bool PlasmaInjector::overlapsWith (const amrex::XDim3& lo, const amrex::XDim3& hi) const noexcept { diff --git a/Source/Particles/MultiParticleContainer.H b/Source/Particles/MultiParticleContainer.H index af63d353d01..40591cf4bad 100644 --- a/Source/Particles/MultiParticleContainer.H +++ b/Source/Particles/MultiParticleContainer.H @@ -30,6 +30,10 @@ # include "Particles/ElementaryProcess/QEDInternals/QuantumSyncEngineWrapper.H" #endif +#ifdef PULSAR + #include "Particles/PulsarParameters.H" +#endif + #include #include @@ -267,6 +271,7 @@ public: #ifdef PULSAR std::string m_E_ext_particle_coord = "cartesian"; std::string m_B_ext_particle_coord = "cartesian"; + void PulsarParticleInjection(); #endif protected: diff --git a/Source/Particles/MultiParticleContainer.cpp b/Source/Particles/MultiParticleContainer.cpp index 0059bbf17e4..3402631f02f 100644 --- a/Source/Particles/MultiParticleContainer.cpp +++ b/Source/Particles/MultiParticleContainer.cpp @@ -1479,3 +1479,14 @@ void MultiParticleContainer::CheckQEDProductSpecies() } #endif + +#ifdef PULSAR +void +MultiParticleContainer::PulsarParticleInjection() +{ + amrex::Print() << " pulsar injection on! \n"; + for (auto& pc : allcontainers) { + pc->PulsarParticleInjection(); + } +} +#endif diff --git a/Source/Particles/PhysicalParticleContainer.H b/Source/Particles/PhysicalParticleContainer.H index 000caf7908e..a91b13fe2d7 100644 --- a/Source/Particles/PhysicalParticleContainer.H +++ b/Source/Particles/PhysicalParticleContainer.H @@ -324,6 +324,10 @@ public: PairGenerationFilterFunc getPairGenerationFilterFunc (); #endif +#ifdef PULSAR + virtual void PulsarParticleInjection () override; +#endif + protected: std::string species_name; std::unique_ptr plasma_injector; diff --git a/Source/Particles/PhysicalParticleContainer.cpp b/Source/Particles/PhysicalParticleContainer.cpp index 576713ec7b0..6dde2e3f7a8 100644 --- a/Source/Particles/PhysicalParticleContainer.cpp +++ b/Source/Particles/PhysicalParticleContainer.cpp @@ -22,7 +22,9 @@ #include "Particles/Pusher/PushSelector.H" #include "Particles/Gather/GetExternalFields.H" #include "Utils/WarpXAlgorithmSelection.H" -#include "Particles/PulsarParameters.H" +#ifdef PULSAR + #include "Particles/PulsarParameters.H" +#endif #include #include @@ -548,6 +550,27 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) { WARPX_PROFILE("PhysicalParticleContainer::AddPlasma()"); +#ifdef PULSAR + amrex::Print() << " in add plasma" << PulsarParm::R_star << "\n"; + // Steps to implement + // 1. inside PulsarBound p.id = -1 if not within R_star+dR_star + // 2. find sigma of the cell the particle belongs to + // 2a. Cell Id of the particle + // 2b. Get x,y,z -> r,theta,phi of the cell. if r >R_star-dR and rthreshold. + // Ninj = sigma*Area/wt + // 2g. We introduce Nc particles every timestep + // Only Ninj are supposed to be injected. + // inject every (ip%(Nc/Ninj)==0) particle + // else p.id = -1 + + +#endif + // If no part_realbox is provided, initialize particles in the whole domain const Geometry& geom = Geom(lev); if (!part_realbox.ok()) part_realbox = geom.ProbDomain(); @@ -841,6 +864,25 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) p.id() = -1; continue; } +#ifdef PULSAR + //amrex::Real xc = PulsarParm::center_star[0]; + //amrex::Real yc = PulsarParm::center_star[1]; + //amrex::Real zc = PulsarParm::center_star[2]; + amrex::Real xc = 90000; + amrex::Real yc = 90000; + amrex::Real zc = 90000; + amrex::Real rad = std::sqrt( (x-xc)*(x-xc) + (y-yc)*(y-yc) + (z-zc)*(z-zc)); + //if (!inj_pos->insidePulsarBounds(r,PulsarParm::R_star,PulsarParm::dR_star)) { + //if (!inj_pos->insidePulsarBounds(r,12000,-2000)) { + if ( (rad< 10000) or (rad>12000) ) { + p.id() = -1; + //amrex::Print() << "call inside pulsar bounds " << r << " rstar " << PulsarParm::R_star << " " << PulsarParm::dR_star<<"\n"; + amrex::Print() << "call inside pulsar bounds " <<"\n"; + continue; + } + else + { amrex::Print() << " r " << rad << "\n";} +#endif u = inj_mom->getMomentum(pos.x, pos.y, z0, engine); dens = inj_rho->getDensity(pos.x, pos.y, z0); @@ -2098,3 +2140,10 @@ PhysicalParticleContainer::getPairGenerationFilterFunc () } #endif + +#ifdef PULSAR +void PhysicalParticleContainer::PulsarParticleInjection() { + + AddPlasma( 0 ); +} +#endif diff --git a/Source/Particles/WarpXParticleContainer.H b/Source/Particles/WarpXParticleContainer.H index 07a9ddcd662..6f6eac78e34 100644 --- a/Source/Particles/WarpXParticleContainer.H +++ b/Source/Particles/WarpXParticleContainer.H @@ -329,6 +329,9 @@ public: bool AmIA () const noexcept {return (physical_species == PhysSpec);} amrex::Array get_v_galilean () {return m_v_galilean;} +#ifdef PULSAR + virtual void PulsarParticleInjection () {}; +#endif /** * \brief Virtual method to resample the species. Overriden by PhysicalParticleContainer only. From e7c13d6689ef05af62968b665c06a82a6a574b6a Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Fri, 17 Jan 2020 20:27:55 -0800 Subject: [PATCH 011/120] pushing changes for comparison --- .../pulsar/inputs.corotating.3d.PM | 11 ++- GNUmakefile | 2 +- Source/Evolve/WarpXEvolve.cpp | 1 - .../Particles/PhysicalParticleContainer.cpp | 84 +++++++++++++++---- 4 files changed, 77 insertions(+), 21 deletions(-) diff --git a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM index 747bf9294d8..9308f561954 100644 --- a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM +++ b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM @@ -50,6 +50,11 @@ interpolation.nox = 3 interpolation.noy = 3 interpolation.noz = 3 +particles.E_ext_particle_init_style = "constant" +particles.E_external_particle = 0.0 0.000 0.0 + + + ################################# ############ PLASMA ############# @@ -61,8 +66,7 @@ plasma_e.charge = -q_e plasma_e.mass = m_e plasma_e.injection_style = "NUniformPerCell" plasma_e.profile = parse_density_function -#plasma_e.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star) * ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<(r_star+dR)) )*dens" -plasma_e.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star) )*dens" +plasma_e.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star) * ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<(r_star+dR)) )*dens" plasma_e.num_particles_per_cell_each_dim = 3 3 3 plasma_e.momentum_distribution_type = parse_momentum_function plasma_e.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))PulsarParticleInjection(); - mypc->Redistribute(); #endif mypc->ApplyBoundaryConditions(); diff --git a/Source/Particles/PhysicalParticleContainer.cpp b/Source/Particles/PhysicalParticleContainer.cpp index 6dde2e3f7a8..24ed546cb3f 100644 --- a/Source/Particles/PhysicalParticleContainer.cpp +++ b/Source/Particles/PhysicalParticleContainer.cpp @@ -553,7 +553,7 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) #ifdef PULSAR amrex::Print() << " in add plasma" << PulsarParm::R_star << "\n"; // Steps to implement - // 1. inside PulsarBound p.id = -1 if not within R_star+dR_star + // 1. inside PulsarBound p.id = -1 if not within R_star+dR_star -- done // 2. find sigma of the cell the particle belongs to // 2a. Cell Id of the particle // 2b. Get x,y,z -> r,theta,phi of the cell. if r >R_star-dR and rdensity_min; Real density_max = plasma_injector->density_max; +#ifdef PULSAR + const MultiFab& Ex_mf = WarpX::GetInstance().getEfield(lev,0); + const MultiFab& Ey_mf = WarpX::GetInstance().getEfield(lev,1); + const MultiFab& Ez_mf = WarpX::GetInstance().getEfield(lev,2); +#endif #ifdef WARPX_DIM_RZ const int nmodes = WarpX::n_rz_azimuthal_modes; bool radially_weighted = plasma_injector->radially_weighted; #endif + MFItInfo info; if (do_tiling && Gpu::notInLaunchRegion()) { info.EnableTiling(tile_size); @@ -636,6 +642,8 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) info.SetDynamic(true); #pragma omp parallel if (not WarpX::serialize_ics) #endif + + for (MFIter mfi = MakeMFIter(lev, info); mfi.isValid(); ++mfi) { if (cost && WarpX::load_balance_costs_update_algo == LoadBalanceCostsUpdateAlgo::Timers) @@ -794,6 +802,31 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) bool loc_do_field_ionization = do_field_ionization; int loc_ionization_initial_level = ionization_initial_level; +#ifdef PULSAR + // Fab + const int Ex_nghost = Ex_mf.nGrow(); + const int Ey_nghost = Ey_mf.nGrow(); + const int Ez_nghost = Ez_mf.nGrow(); + const FArrayBox& Ex_fab = Ex_mf[mfi]; + const FArrayBox& Ey_fab = Ey_mf[mfi]; + const FArrayBox& Ez_fab = Ez_mf[mfi]; + Box Ex_box = Ex_fab.box(); + Box Ey_box = Ey_fab.box(); + Box Ez_box = Ez_fab.box(); + const Dim3 Ex_lo = lbound(mfi.tilebox()); + const Dim3 Ey_lo = lbound(mfi.tilebox()); + const Dim3 Ez_lo = lbound(mfi.tilebox()); + amrex::Array4 const& ex_arr = Ex_fab.array(); + amrex::Array4 const& ey_arr = Ey_fab.array(); + amrex::Array4 const& ez_arr = Ez_fab.array(); + //amrex::Print() << " box " << x_box << "\n"; + //FArrayBox Ey_fab = Ey_mf[mfi]; + //Box Ey_box = Ey_fab.validbox(); + //FArrayBox Ez_fab = Ez_mf[mfi]; + //Box Ez_box = Ez_fab.validbox(); + //amrex::Print() << " Ey box " << Ey_box << "\n"; + //amrex::Print() << " Ez box " << Ez_box << "\n"; +#endif // Loop over all new particles and inject them (creates too many // particles, in particular does not consider xmin, xmax etc.). @@ -865,23 +898,44 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) continue; } #ifdef PULSAR - //amrex::Real xc = PulsarParm::center_star[0]; - //amrex::Real yc = PulsarParm::center_star[1]; - //amrex::Real zc = PulsarParm::center_star[2]; - amrex::Real xc = 90000; - amrex::Real yc = 90000; - amrex::Real zc = 90000; - amrex::Real rad = std::sqrt( (x-xc)*(x-xc) + (y-yc)*(y-yc) + (z-zc)*(z-zc)); - //if (!inj_pos->insidePulsarBounds(r,PulsarParm::R_star,PulsarParm::dR_star)) { - //if (!inj_pos->insidePulsarBounds(r,12000,-2000)) { - if ( (rad< 10000) or (rad>12000) ) { + amrex::Real xc = PulsarParm::center_star[0]; + amrex::Real yc = PulsarParm::center_star[1]; + amrex::Real zc = PulsarParm::center_star[2]; + amrex::Real rad = std::sqrt( (xb-xc)*(xb-xc) + + (yb-yc)*(yb-yc) + (zb-zc)*(zb-zc) ); + if (!inj_pos->insidePulsarBounds(rad,PulsarParm::R_star,PulsarParm::dR_star)) { p.id() = -1; - //amrex::Print() << "call inside pulsar bounds " << r << " rstar " << PulsarParm::R_star << " " << PulsarParm::dR_star<<"\n"; - amrex::Print() << "call inside pulsar bounds " <<"\n"; continue; } - else - { amrex::Print() << " r " << rad << "\n";} + // get cell center + amrex::Real cc_x = overlap_corner[0] + iv[0]*dx[0] + 0.5*dx[0] ; + amrex::Real cc_y = overlap_corner[1] + iv[1]*dx[1] + 0.5*dx[1] ; + amrex::Real cc_z = overlap_corner[2] + iv[2]*dx[2] + 0.5*dx[2] ; + // get spherical r, theta, phi + amrex::Real cc_rad = std::sqrt( (cc_x-xc)*(cc_x-xc) + + (cc_y-yc)*(cc_y-yc) + + (cc_z-zc)*(cc_z-zc)); + amrex::Real cc_theta = 0; + if (cc_rad > 0 ) { + cc_theta = std::acos((cc_z-xc)/cc_rad); + } + amrex::Real cc_phi = std::atan2((cc_y-yc),(cc_x-xc)); + const amrex::Real c_theta = std::cos(cc_theta); + const amrex::Real s_theta = std::sin(cc_theta); + const amrex::Real c_phi = std::cos(cc_phi); + const amrex::Real s_phi = std::sin(cc_phi); + amrex::Print() << " tile box = " << tile_box << "\n"; + amrex::Print() << " iv " << iv[0] << " " << iv[1] << " " << iv[2] << "\n"; + int ii = Ex_lo.x + iv[0]; + int jj = Ex_lo.y + iv[1]; + int kk = Ex_lo.z + iv[2]; + amrex::Real Er_cor = -2.0*PulsarParm::B_star + *PulsarParm::omega_star + *cc_rad*s_theta*s_theta; + amrex::Print() << " Ex : " << Ex_box << "\n"; + amrex::Print() << " Er cor : " << Er_cor << "\n"; + amrex::Print() << " ex_arr " << ex_arr(ii,jj,kk) << " ii " << ii << " jj " << jj << " kk " << kk << "\n"; + amrex::Print() << " overlap box " << overlap_box << "\n"; #endif u = inj_mom->getMomentum(pos.x, pos.y, z0, engine); From 0057ca3d79ff1ab17b4f62ce934fb1176cc7aae9 Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Tue, 21 Jan 2020 14:24:03 -0800 Subject: [PATCH 012/120] particles injected below surface, dipole magnetic field inside and outside, momentum of all particles is zero, fixed function that applied vacuum EB fields on particles --- .../pulsar/inputs.corotating.3d.PM | 47 +- .../pulsar/pulsar_viz.ipynb | 739 ++++++++++++++++++ Source/Evolve/WarpXEvolve.cpp | 1 + Source/Initialization/InjectorPosition.H | 3 +- Source/Particles/MultiParticleContainer.H | 1 + Source/Particles/MultiParticleContainer.cpp | 9 + Source/Particles/PhysicalParticleContainer.H | 1 + .../Particles/PhysicalParticleContainer.cpp | 93 ++- Source/Particles/PulsarParameters.H | 4 +- Source/Particles/PulsarParameters.cpp | 36 +- Source/Particles/WarpXParticleContainer.H | 1 + 11 files changed, 897 insertions(+), 38 deletions(-) create mode 100644 Examples/Physics_applications/pulsar/pulsar_viz.ipynb diff --git a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM index 9308f561954..8df4ef4e50f 100644 --- a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM +++ b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM @@ -20,7 +20,7 @@ amr.max_grid_size = 64 amr.blocking_factor = 64 amr.max_level = 0 amr.plot_file = "plotfiles/plt" -amr.plot_int = 1 +amr.plot_int = 2 geometry.coord_sys = 0 # 0: Cartesian geometry.is_periodic = 0 0 0 # Is periodic? geometry.prob_lo = 0.0 0.0 0.0 @@ -34,7 +34,7 @@ warpx.verbose = 1 warpx.plot_raw_fields = 0 warpx.do_dive_cleaning = 0 warpx.use_filter = 1 -warpx.cfl = .99 +warpx.cfl = .5 warpx.fields_to_plot = Ex Ey Ez Bx By Bz jx jy jz part_per_cell rho divE my_constants.pi = 3.141592653589793 my_constants.dens = 5.544e6 @@ -46,12 +46,16 @@ my_constants.omega = 6245.676 my_constants.c = 299792458. my_constants.B_star = 8.0323e-6 # magnetic field of NS (T) my_constants.dR = 2e3 +my_constants.to = -2e-4 interpolation.nox = 3 interpolation.noy = 3 interpolation.noz = 3 -particles.E_ext_particle_init_style = "constant" -particles.E_external_particle = 0.0 0.000 0.0 +#warpx.E_ext_grid_init_style = "parse_E_ext_grid_function" +#warpx.Ex_external_grid_function(x,y,z) = "((x-xc)*(x-xc)+(y-yc)*(y-yc) + (z-zc)*(z-zc))^0.5" +#warpx.Ey_external_grid_function(x,y,z) = "((x-xc)*(x-xc)+(y-yc)*(y-yc) + (z-zc)*(z-zc))^0.5" +#warpx.Ez_external_grid_function(x,y,z) = "((x-xc)*(x-xc)+(y-yc)*(y-yc) + (z-zc)*(z-zc))^0.5" + @@ -66,12 +70,21 @@ plasma_e.charge = -q_e plasma_e.mass = m_e plasma_e.injection_style = "NUniformPerCell" plasma_e.profile = parse_density_function -plasma_e.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star) * ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<(r_star+dR)) )*dens" +#plasma_e.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star) * ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<(r_star+dR)) )*dens" +plasma_e.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star) * ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=(r_star-dR)) )*dens" plasma_e.num_particles_per_cell_each_dim = 3 3 3 plasma_e.momentum_distribution_type = parse_momentum_function -plasma_e.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "['./particle_in_ring.png']" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "sl = yt.SlicePlot(ds, 0, 'Ez', aspect=1) # Create a sliceplot object\n", + "sl.annotate_particles(width=(2.e3, 'm'),ptype=\"plasma_p\",col='b',p_size=5.0)\n", + "sl.annotate_particles(width=(2.e3, 'm'),ptype=\"plasma_e\",col='r',p_size=5.0)\n", + "sl.annotate_streamlines(\"Ey\", \"Ez\", plot_args={\"color\": \"black\"})\n", + "sl.annotate_grids() # Show grids\n", + "sl.annotate_sphere([90000.0, 90000.0, 90000.0], radius=12000.0,\n", + " circle_args={'color':'white', 'linewidth':2})\n", + "sl.show() # Show the plot\n", + "sl.save('./particle_in_ring.png')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from yt.units.yt_array import YTQuantity\n", + "from yt.units import kboltz\n", + "from numpy.random import random\n", + "import numpy as np\n", + "from yt.utilities.exceptions import YTUnitOperationError\n", + "def r_cl(field,data):\n", + " xc = YTQuantity(90000, 'm')\n", + " yc = YTQuantity(90000, 'm')\n", + " zc = YTQuantity(90000, 'm')\n", + "\n", + " r = ((data[\"y\"]-yc)*(data[\"y\"]-yc) + (data[\"x\"]-xc)*(data[\"x\"]-xc))**0.5\n", + "\n", + " return r" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "ds.add_field((\"index\",\"r_cl\"),function=r_cl,units='m',sampling_type=\"cell\")\n", + "#yt.SlicePlot(ds,'z','r_cl')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from yt.units.yt_array import YTQuantity\n", + "from yt.units import kboltz\n", + "from numpy.random import random\n", + "import numpy as np\n", + "from yt.utilities.exceptions import YTUnitOperationError\n", + "def rad(field,data):\n", + " xc = YTQuantity(90000, 'm')\n", + " yc = YTQuantity(90000, 'm')\n", + " zc = YTQuantity(90000, 'm')\n", + "\n", + " r = ((data[\"y\"]-yc)*(data[\"y\"]-yc) + (data[\"x\"]-xc)*(data[\"x\"]-xc) + (data[\"z\"]-zc)*(data[\"z\"]-zc))**0.5\n", + "\n", + " return r" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "ds.add_field((\"index\",\"rad\"),function=rad,units='m',sampling_type=\"cell\")\n", + "#yt.SlicePlot(ds,'z','rad')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Store quantities in numpy arrays, and plot with matplotlib" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "from yt.units.yt_array import YTQuantity\n", + "from yt.units import kboltz\n", + "from numpy.random import random\n", + "import numpy as np\n", + "from yt.utilities.exceptions import YTUnitOperationError\n", + "def Ex_external(field,data):\n", + " xc = YTQuantity(90000, 'm')\n", + " yc = YTQuantity(90000, 'm')\n", + " zc = YTQuantity(90000, 'm')\n", + " r_star = YTQuantity(12000, 'm')\n", + " omega = 6245.8\n", + " B = 8.03e-6\n", + " r = ((data[\"y\"]-yc)*(data[\"y\"]-yc) + (data[\"x\"]-xc)*(data[\"x\"]-xc) + (data[\"z\"]-zc)*(data[\"z\"]-zc))**0.5\n", + " c_theta = (data[\"z\"]-zc)/r\n", + " s_theta = data[\"r_cl\"]/r\n", + " c_phi = (data[\"x\"]-xc)/data[\"r_cl\"]\n", + " s_phi = (data[\"y\"]-yc)/data[\"r_cl\"]\n", + " r_ratio = r_star/r\n", + " r3 = r_ratio*r_ratio*r_ratio\n", + " Er = omega*r_star*B*r3*r_ratio*(1.0-3.0*c_theta*c_theta) \n", + " #+ (2.0/3.0)*omega*B*r_star*r_ratio*r_ratio\n", + " E_theta = (-1)*omega*B*r_star*r3*r_ratio*(c_theta*s_theta*2.0)\n", + " Ex_ext = Er*c_phi*s_theta + E_theta*c_phi*c_theta\n", + "\n", + " outside = np.zeros_like(data[\"r_cl\"])\n", + " outside[data[\"rad\"] > 12000] = 1.0\n", + "\n", + " \n", + " return outside.d*Ex_ext.d" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "from yt.units.yt_array import YTQuantity\n", + "from yt.units import kboltz\n", + "from numpy.random import random\n", + "import numpy as np\n", + "from yt.utilities.exceptions import YTUnitOperationError\n", + "def Ex_internal(field,data):\n", + " xc = YTQuantity(90000, 'm')\n", + " yc = YTQuantity(90000, 'm')\n", + " zc = YTQuantity(90000, 'm')\n", + " r_star = YTQuantity(12000, 'm')\n", + " omega = 6245.8\n", + " B = 8.03e-6\n", + " r = ((data[\"y\"]-yc)*(data[\"y\"]-yc) + (data[\"x\"]-xc)*(data[\"x\"]-xc) + (data[\"z\"]-zc)*(data[\"z\"]-zc))**0.5\n", + " c_theta = (data[\"z\"]-zc)/r\n", + " s_theta = data[\"r_cl\"]/r\n", + " c_phi = (data[\"x\"]-xc)/data[\"r_cl\"]\n", + " s_phi = (data[\"y\"]-yc)/data[\"r_cl\"]\n", + " r_ratio = r_star/r\n", + " r3 = r_ratio*r_ratio*r_ratio\n", + " Er = omega*r*r3*B*s_theta*s_theta\n", + " E_theta = (-1)*omega*B*r*r3*(c_theta*s_theta*2.0)\n", + " Ex_ext = Er*c_phi*s_theta + E_theta*c_phi*c_theta\n", + "\n", + " outside = np.zeros_like(data[\"r_cl\"])\n", + " outside[data[\"rad\"] <= 12000] = 1.0\n", + "\n", + " \n", + " return outside.d*Ex_ext.d" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "from yt.units.yt_array import YTQuantity\n", + "from yt.units import kboltz\n", + "from numpy.random import random\n", + "import numpy as np\n", + "from yt.utilities.exceptions import YTUnitOperationError\n", + "def Ey_external(field,data):\n", + " xc = YTQuantity(90000, 'm')\n", + " yc = YTQuantity(90000, 'm')\n", + " zc = YTQuantity(90000, 'm')\n", + " r_star = YTQuantity(12000, 'm')\n", + " omega = 6245.8\n", + " B = 8.03e-6\n", + "\n", + " r = ((data[\"y\"]-yc)*(data[\"y\"]-yc) + (data[\"x\"]-xc)*(data[\"x\"]-xc) + (data[\"z\"]-zc)*(data[\"z\"]-zc))**0.5\n", + " c_theta = (data[\"z\"]-zc)/r\n", + " s_theta = data[\"r_cl\"]/r\n", + " c_phi = (data[\"x\"]-xc)/data[\"r_cl\"]\n", + " s_phi = (data[\"y\"]-yc)/data[\"r_cl\"]\n", + " r_ratio = r_star/r\n", + " r3 = r_ratio*r_ratio*r_ratio\n", + " Er = omega*r_star*B*r3*r_ratio*(1.0-3.0*c_theta*c_theta) \n", + " # + (2.0/3.0)*omega*B*r_star*r_ratio*r_ratio\n", + " E_theta = (-1)*omega*B*r_star*r3*r_ratio*(c_theta*s_theta*2.0)\n", + " Ey_ext = Er*s_phi*s_theta + E_theta*s_phi*c_theta\n", + "\n", + " outside = np.zeros_like(data[\"r_cl\"])\n", + " outside[data[\"rad\"] > 12000] = 1.0\n", + "\n", + " \n", + " return outside.d*Ey_ext.d" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "from yt.units.yt_array import YTQuantity\n", + "from yt.units import kboltz\n", + "from numpy.random import random\n", + "import numpy as np\n", + "from yt.utilities.exceptions import YTUnitOperationError\n", + "def Ey_internal(field,data):\n", + " xc = YTQuantity(90000, 'm')\n", + " yc = YTQuantity(90000, 'm')\n", + " zc = YTQuantity(90000, 'm')\n", + " r_star = YTQuantity(12000, 'm')\n", + " omega = 6245.8\n", + " B = 8.03e-6\n", + " r = ((data[\"y\"]-yc)*(data[\"y\"]-yc) + (data[\"x\"]-xc)*(data[\"x\"]-xc) + (data[\"z\"]-zc)*(data[\"z\"]-zc))**0.5\n", + " c_theta = (data[\"z\"]-zc)/r\n", + " s_theta = data[\"r_cl\"]/r\n", + " c_phi = (data[\"x\"]-xc)/data[\"r_cl\"]\n", + " s_phi = (data[\"y\"]-yc)/data[\"r_cl\"]\n", + " r_ratio = r_star/r\n", + " r3 = r_ratio*r_ratio*r_ratio\n", + " Er = omega*r*r3*B*s_theta*s_theta\n", + " E_theta = (-1)*omega*B*r*r3*(c_theta*s_theta*2.0)\n", + " Ey_ext = Er*s_phi*s_theta + E_theta*s_phi*c_theta\n", + " outside = np.zeros_like(data[\"r_cl\"])\n", + " outside[data[\"rad\"] <= 12000] = 1.0\n", + "\n", + " \n", + " return outside.d*Ey_ext.d" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "from yt.units.yt_array import YTQuantity\n", + "from yt.units import kboltz\n", + "from numpy.random import random\n", + "import numpy as np\n", + "from yt.utilities.exceptions import YTUnitOperationError\n", + "def Ez_external(field,data):\n", + " xc = YTQuantity(90000, 'm')\n", + " yc = YTQuantity(90000, 'm')\n", + " zc = YTQuantity(90000, 'm')\n", + " r_star = YTQuantity(12000, 'm')\n", + " omega = 6245.8\n", + " B = 8.03e-6\n", + " r = ((data[\"y\"]-yc)*(data[\"y\"]-yc) + (data[\"x\"]-xc)*(data[\"x\"]-xc) + (data[\"z\"]-zc)*(data[\"z\"]-zc))**0.5\n", + " c_theta = (data[\"z\"]-zc)/r\n", + " s_theta = data[\"r_cl\"]/r\n", + " c_phi = (data[\"x\"]-xc)/data[\"r_cl\"]\n", + " s_phi = (data[\"y\"]-yc)/data[\"r_cl\"]\n", + " r_ratio = r_star/r\n", + " r3 = r_ratio*r_ratio*r_ratio\n", + " Er = omega*r_star*B*r3*r_ratio*(1.0-3.0*c_theta*c_theta) \n", + " # + (2.0/3.0)*omega*B*r_star*r_ratio*r_ratio\n", + " E_theta = (-1)*omega*B*r_star*r3*r_ratio*(c_theta*s_theta*2.0)\n", + " Ez_ext = Er*c_theta - E_theta*s_theta\n", + "\n", + " outside = np.zeros_like(data[\"r_cl\"])\n", + " outside[data[\"rad\"] > 12000] = 1.0\n", + "\n", + " \n", + " return outside.d*Ez_ext.d \n", + " #return outside.d*Er.d" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "from yt.units.yt_array import YTQuantity\n", + "from yt.units import kboltz\n", + "from numpy.random import random\n", + "import numpy as np\n", + "from yt.utilities.exceptions import YTUnitOperationError\n", + "def Ez_internal(field,data):\n", + " xc = YTQuantity(90000, 'm')\n", + " yc = YTQuantity(90000, 'm')\n", + " zc = YTQuantity(90000, 'm')\n", + " r_star = YTQuantity(12000, 'm')\n", + " omega = 6245.8\n", + " B = 8.03e-6\n", + " r = ((data[\"y\"]-yc)*(data[\"y\"]-yc) + (data[\"x\"]-xc)*(data[\"x\"]-xc) + (data[\"z\"]-zc)*(data[\"z\"]-zc))**0.5\n", + " c_theta = (data[\"z\"]-zc)/r\n", + " s_theta = data[\"r_cl\"]/r\n", + " c_phi = (data[\"x\"]-xc)/data[\"r_cl\"]\n", + " s_phi = (data[\"y\"]-yc)/data[\"r_cl\"]\n", + " r_ratio = r_star/r\n", + " r3 = r_ratio*r_ratio*r_ratio\n", + " Er = omega*r*r3*B*s_theta*s_theta\n", + " E_theta = (-1)*omega*B*r*r3*(c_theta*s_theta*2.0)\n", + " Ez_ext = Er*c_theta - E_theta*s_theta\n", + "\n", + " outside = np.zeros_like(data[\"r_cl\"])\n", + " outside[data[\"rad\"] <= 12000] = 1.0\n", + "\n", + " \n", + " return outside.d*Ez_ext.d\n", + " # return outside.d*Er.d" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "from yt.units.yt_array import YTQuantity\n", + "from yt.units import kboltz\n", + "from numpy.random import random\n", + "import numpy as np\n", + "from yt.utilities.exceptions import YTUnitOperationError\n", + "def Ex_total_ext(field,data):\n", + "\n", + " return data[\"Ex_internal\"] + data[\"Ex_external\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "from yt.units.yt_array import YTQuantity\n", + "from yt.units import kboltz\n", + "from numpy.random import random\n", + "import numpy as np\n", + "from yt.utilities.exceptions import YTUnitOperationError\n", + "def Ey_total_ext(field,data):\n", + "\n", + " return data[\"Ey_internal\"] + data[\"Ey_external\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "from yt.units.yt_array import YTQuantity\n", + "from yt.units import kboltz\n", + "from numpy.random import random\n", + "import numpy as np\n", + "from yt.utilities.exceptions import YTUnitOperationError\n", + "def Ez_total_ext(field,data):\n", + "\n", + " return data[\"Ez_internal\"] + data[\"Ez_external\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds.add_field((\"Ex_external\"),function=Ex_external,units='',sampling_type=\"cell\")\n", + "ds.add_field((\"Ey_external\"),function=Ey_external,units='',sampling_type=\"cell\")\n", + "ds.add_field((\"Ez_external\"),function=Ez_external,units='',sampling_type=\"cell\")\n", + "ds.add_field((\"Ex_internal\"),function=Ex_internal,units='',sampling_type=\"cell\")\n", + "ds.add_field((\"Ey_internal\"),function=Ey_internal,units='',sampling_type=\"cell\")\n", + "ds.add_field((\"Ez_internal\"),function=Ez_internal,units='',sampling_type=\"cell\")\n", + "ds.add_field((\"Ex_total_ext\"),function=Ex_total_ext,units='',sampling_type=\"cell\")\n", + "ds.add_field((\"Ey_total_ext\"),function=Ey_total_ext,units='',sampling_type=\"cell\")\n", + "ds.add_field((\"Ez_total_ext\"),function=Ez_total_ext,units='',sampling_type=\"cell\")\n", + "\n", + "p = yt.SlicePlot(ds,'x','Ez_external')\n", + "p.annotate_streamlines(\"Ey_external\", \"Ez_external\", \n", + " plot_args={\"color\": \"black\"})\n", + "#p.annotate_particles(width=(2.e3, 'm'),ptype=\"plasma_p\",col='b',p_size=5.0)\n", + "#p.annotate_particles(width=(2.e3, 'm'),ptype=\"plasma_e\",col='r',p_size=5.0)\n", + "p.show()\n", + "p = yt.SlicePlot(ds,'x','Ez_internal')\n", + "p.annotate_streamlines(\"Ey_internal\", \"Ez_internal\", \n", + " plot_args={\"color\": \"black\"})" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "['uniform_ring_50ppc.png']" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p = yt.ParticlePlot(ds,('plasma_p', 'particle_position_x'),('plasma_p', 'particle_position_y'),('plasma_p', 'particle_momentum_x'))\n", + "p.show()\n", + "p.save(\"uniform_ring_50ppc.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "['uniform_ring_50ppc.png']" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p = yt.ParticlePlot(ds,('plasma_e', 'particle_position_x'),('plasma_e', 'particle_position_y'),('plasma_e', 'particle_momentum_x'))\n", + "\n", + "p.show()\n", + "p.save(\"uniform_ring_50ppc.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Read data back-transformed to the lab frame when the simulation runs in the boosted frame (example: 2D run)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "# read_raw_data.py is located in warpx/Tools.\n", + "import os, glob\n", + "#import read_raw_data" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "#species = 'beam'\n", + "#iteration = 1\n", + "#field = 'Ex'\n", + "\n", + "#snapshot = './lab_frame_data/' + 'snapshot' + str(iteration).zfill(5)\n", + "#header = './lab_frame_data/Header'\n", + "#allrd, info = read_raw_data.read_lab_snapshot(snapshot, header) # Read field data\n", + "#F = allrd[field]\n", + "#print( \"Available info: \", *list(info.keys()) )\n", + "#print(\"Available fields: \", info['field_names'])\n", + "#nx = info['nx']\n", + "#nz = info['nz']\n", + "#x = info['x']\n", + "#z = info['z']\n", + "#xbo = read_raw_data.get_particle_field(snapshot, species, 'x') # Read particle data\n", + "#ybo = read_raw_data.get_particle_field(snapshot, species, 'y')\n", + "#zbo = read_raw_data.get_particle_field(snapshot, species, 'z')\n", + "#uzbo = read_raw_data.get_particle_field(snapshot, species, 'uz')\n", + "\n", + "#plt.figure(figsize=(6, 3))\n", + "#extent = np.array([info['zmin'], info['zmax'], info['xmin'], info['xmax']])\n", + "#plt.imshow(F, aspect='auto', extent=extent, cmap='seismic')\n", + "#plt.colorbar()\n", + "#plt.plot(zbo, xbo, 'g.', markersize=1.)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Read back-transformed data with hdf5 format (example: 3D run)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5e10*1400*1400" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "9800000000000.0" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "5e6*1400*1400" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1343987680000" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "685708*1400*1400" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.2" + }, + "widgets": { + "state": { + "11d243e9f5074fe1b115949d174d59de": { + "views": [ + { + "cell_index": 6 + } + ] + } + }, + "version": "1.2.0" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Source/Evolve/WarpXEvolve.cpp b/Source/Evolve/WarpXEvolve.cpp index 099b964b54b..8854384dc10 100644 --- a/Source/Evolve/WarpXEvolve.cpp +++ b/Source/Evolve/WarpXEvolve.cpp @@ -205,6 +205,7 @@ WarpX::Evolve (int numsteps) int num_moved = MoveWindow(move_j); #ifdef PULSAR + mypc->PulsarParticleRemoval(); mypc->PulsarParticleInjection(); #endif diff --git a/Source/Initialization/InjectorPosition.H b/Source/Initialization/InjectorPosition.H index e24e629b1ab..b18d5124bcb 100644 --- a/Source/Initialization/InjectorPosition.H +++ b/Source/Initialization/InjectorPosition.H @@ -139,7 +139,8 @@ struct InjectorPosition bool insidePulsarBounds (amrex::Real r, amrex::Real R_star, amrex::Real dR_star) const noexcept { - return (r>=R_star and r<=(R_star+dR_star)); + // return (r>=R_star and r<=(R_star+dR_star)); + return (r<=R_star and r>=(R_star-dR_star)); } #endif diff --git a/Source/Particles/MultiParticleContainer.H b/Source/Particles/MultiParticleContainer.H index 40591cf4bad..b57a7c2cc01 100644 --- a/Source/Particles/MultiParticleContainer.H +++ b/Source/Particles/MultiParticleContainer.H @@ -272,6 +272,7 @@ public: std::string m_E_ext_particle_coord = "cartesian"; std::string m_B_ext_particle_coord = "cartesian"; void PulsarParticleInjection(); + void PulsarParticleRemoval(); #endif protected: diff --git a/Source/Particles/MultiParticleContainer.cpp b/Source/Particles/MultiParticleContainer.cpp index 3402631f02f..f75a759e9d8 100644 --- a/Source/Particles/MultiParticleContainer.cpp +++ b/Source/Particles/MultiParticleContainer.cpp @@ -1489,4 +1489,13 @@ MultiParticleContainer::PulsarParticleInjection() pc->PulsarParticleInjection(); } } +void +MultiParticleContainer::PulsarParticleRemoval() +{ + amrex::Print() << " pulsar particle removal on! \n"; + for (auto& pc : allcontainers) { + pc->PulsarParticleRemoval(); + } + +} #endif diff --git a/Source/Particles/PhysicalParticleContainer.H b/Source/Particles/PhysicalParticleContainer.H index a91b13fe2d7..01da5525fa0 100644 --- a/Source/Particles/PhysicalParticleContainer.H +++ b/Source/Particles/PhysicalParticleContainer.H @@ -326,6 +326,7 @@ public: #ifdef PULSAR virtual void PulsarParticleInjection () override; + virtual void PulsarParticleRemoval () override; #endif protected: diff --git a/Source/Particles/PhysicalParticleContainer.cpp b/Source/Particles/PhysicalParticleContainer.cpp index 24ed546cb3f..6803dec3f29 100644 --- a/Source/Particles/PhysicalParticleContainer.cpp +++ b/Source/Particles/PhysicalParticleContainer.cpp @@ -626,6 +626,8 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) const MultiFab& Ex_mf = WarpX::GetInstance().getEfield(lev,0); const MultiFab& Ey_mf = WarpX::GetInstance().getEfield(lev,1); const MultiFab& Ez_mf = WarpX::GetInstance().getEfield(lev,2); + const Real dt = WarpX::GetInstance().getdt(0); +// if (t > 100*dt) {return;} #endif #ifdef WARPX_DIM_RZ @@ -810,15 +812,13 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) const FArrayBox& Ex_fab = Ex_mf[mfi]; const FArrayBox& Ey_fab = Ey_mf[mfi]; const FArrayBox& Ez_fab = Ez_mf[mfi]; - Box Ex_box = Ex_fab.box(); - Box Ey_box = Ey_fab.box(); - Box Ez_box = Ez_fab.box(); const Dim3 Ex_lo = lbound(mfi.tilebox()); const Dim3 Ey_lo = lbound(mfi.tilebox()); const Dim3 Ez_lo = lbound(mfi.tilebox()); amrex::Array4 const& ex_arr = Ex_fab.array(); amrex::Array4 const& ey_arr = Ey_fab.array(); amrex::Array4 const& ez_arr = Ez_fab.array(); + const Real q_pm = this->charge; //amrex::Print() << " box " << x_box << "\n"; //FArrayBox Ey_fab = Ey_mf[mfi]; //Box Ey_box = Ey_fab.validbox(); @@ -924,18 +924,51 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) const amrex::Real s_theta = std::sin(cc_theta); const amrex::Real c_phi = std::cos(cc_phi); const amrex::Real s_phi = std::sin(cc_phi); - amrex::Print() << " tile box = " << tile_box << "\n"; - amrex::Print() << " iv " << iv[0] << " " << iv[1] << " " << iv[2] << "\n"; + amrex::Real omega = PulsarParm::omega_star; + if (t < 2.0e-4) { + omega = PulsarParm::omega_star*t/2.0e-4; + } + amrex::Real ratio = PulsarParm::R_star/cc_rad; + amrex::Real r3 = ratio*ratio*ratio; + amrex::Real Er_cor = PulsarParm::B_star + *omega + *PulsarParm::R_star*s_theta*s_theta; + Real Er_ext = omega*PulsarParm::B_star*PulsarParm::R_star + *(1.0-3.0*c_theta*c_theta); int ii = Ex_lo.x + iv[0]; int jj = Ex_lo.y + iv[1]; int kk = Ex_lo.z + iv[2]; - amrex::Real Er_cor = -2.0*PulsarParm::B_star - *PulsarParm::omega_star - *cc_rad*s_theta*s_theta; - amrex::Print() << " Ex : " << Ex_box << "\n"; - amrex::Print() << " Er cor : " << Er_cor << "\n"; - amrex::Print() << " ex_arr " << ex_arr(ii,jj,kk) << " ii " << ii << " jj " << jj << " kk " << kk << "\n"; - amrex::Print() << " overlap box " << overlap_box << "\n"; + Real ex_avg = 0.25*(ex_arr(ii,jj,kk) + ex_arr(ii,jj+1,kk)+ex_arr(ii,jj,kk+1) + ex_arr(ii,jj+1,kk+1)); + Real ey_avg = 0.25*(ex_arr(ii,jj,kk) + ex_arr(ii+1,jj,kk)+ex_arr(ii,jj,kk+1) + ex_arr(ii+1,jj,kk+1)); + Real ez_avg = 0.25*(ex_arr(ii,jj,kk) + ex_arr(ii,jj+1,kk)+ex_arr(ii+1,jj,kk) + ex_arr(ii+1,jj+1,kk)); + Real Er_cell = ex_avg*s_theta*c_phi + ey_avg*s_theta*s_phi + ez_avg*c_theta; + Real sigma_inj = ((Er_cell - Er_cor)); + Real max_dens = 5.54e6; + Real N_inj = 0.2*std::abs(sigma_inj) * dx[0]*dx[0]* 8.85e-12/(1.609e-19*max_dens*scale_fac); + //amrex::Print() << " ex_arr " << ex_avg << " ey avg " << ey_avg << " ez_avg " << ez_avg << " E_cell " << Er_cell << " Er_corr " << Er_cor << " sigma inj " << sigma_inj << " ninj " << N_inj << " num pcc " << num_ppc << " dt " << dt << " t " << t << "\n"; + // amrex::Print() << " ex_arr " << ex_avg << " ey avg " << ey_avg << " ez_avg " << ez_avg << " Er_cell " << Er_cell << " Er ext " << Er_ext << " Er_corr " << Er_cor << " sigma inj " << sigma_inj << " ninj " << N_inj << " num pcc " << num_ppc << " ccrad " << cc_rad << " t "<< t << "\n"; + if (t > 0) { + if (N_inj >= 1) { + int part_freq = floor(num_ppc / N_inj); + if (N_inj < num_ppc) { + if (i_part%part_freq!=0) { + p.id() = -1; + continue; + } + } + } + else + { + p.id() = -1; + continue; + } + } + ////if (N_inj < 1) { p.id() = -1; return;} + //if (t > 0) { + // if (sigma_inj < 0 and q_pm >0) {p.id()=-1; return;} + // if (sigma_inj > 0 and q_pm <0) {p.id()=-1; return;} + //} + #endif u = inj_mom->getMomentum(pos.x, pos.y, z0, engine); @@ -2200,4 +2233,40 @@ void PhysicalParticleContainer::PulsarParticleInjection() { AddPlasma( 0 ); } + +void PhysicalParticleContainer::PulsarParticleRemoval() { + int lev = 0; + // Remove Particles From inside sphere +#ifdef _OPENMP +#pragma omp parallel +#endif + { +#ifdef _OPENMP + int thread_num = omp_get_thread_num(); +#else + int thread_num = 0; +#endif + for (WarpXParIter pti(*this, lev); pti.isValid(); ++pti) + { + pti.GetPosition(m_xp[thread_num], m_yp[thread_num], m_zp[thread_num]); + Real* const AMREX_RESTRICT xp_data = m_xp[thread_num].dataPtr(); + Real* const AMREX_RESTRICT yp_data = m_yp[thread_num].dataPtr(); + Real* const AMREX_RESTRICT zp_data = m_zp[thread_num].dataPtr(); + Real xc = PulsarParm::center_star[0]; + Real yc = PulsarParm::center_star[1]; + Real zc = PulsarParm::center_star[2]; + ParticleType* pp = pti.GetArrayOfStructs()().data(); + amrex::ParallelFor(pti.numParticles(), + [=] AMREX_GPU_DEVICE (long i) { + + Real r = std::sqrt((xp_data[i]-xc)*(xp_data[i]-xc) + + (yp_data[i]-yc)*(yp_data[i]-yc) + + (zp_data[i]-zc)*(zp_data[i]-zc)); + if (r<=PulsarParm::R_star - PulsarParm::dR_star) { + pp[i].id() = -1; + } + }); + } + } +} #endif diff --git a/Source/Particles/PulsarParameters.H b/Source/Particles/PulsarParameters.H index 97741a71c69..17953a4ff81 100644 --- a/Source/Particles/PulsarParameters.H +++ b/Source/Particles/PulsarParameters.H @@ -21,8 +21,8 @@ namespace PulsarParm void ReadParameters(); void PulsarEBField(amrex::Real xp, amrex::Real yp, amrex::Real zp, - amrex::Real Exp, amrex::Real Eyp, amrex::Real Ezp, - amrex::Real Bxp, amrex::Real Byp, amrex::Real Bzp, + amrex::Real &Exp, amrex::Real &Eyp, amrex::Real &Ezp, + amrex::Real &Bxp, amrex::Real &Byp, amrex::Real &Bzp, amrex::Real time); } diff --git a/Source/Particles/PulsarParameters.cpp b/Source/Particles/PulsarParameters.cpp index cf0784f9bd6..748af9a3559 100644 --- a/Source/Particles/PulsarParameters.cpp +++ b/Source/Particles/PulsarParameters.cpp @@ -35,8 +35,8 @@ namespace PulsarParm } void PulsarEBField(amrex::Real xp, amrex::Real yp, amrex::Real zp, - amrex::Real Exp, amrex::Real Eyp, amrex::Real Ezp, - amrex::Real Bxp, amrex::Real Byp, amrex::Real Bzp, + amrex::Real &Exp, amrex::Real &Eyp, amrex::Real &Ezp, + amrex::Real &Bxp, amrex::Real &Byp, amrex::Real &Bzp, amrex::Real time) { // spherical r, theta, phi const amrex::Real xc = center_star[0]; @@ -52,34 +52,48 @@ namespace PulsarParm const amrex::Real s_theta = std::sin(theta); const amrex::Real c_phi = std::cos(phi); const amrex::Real s_phi = std::sin(phi); + amrex::Real omega = omega_star; + if (time < 2.0e-4) { + omega = omega_star*time/2.0e-4; + } // Inside star :: uniform B a,d E = - (omega X r) X B if (r= R_star) { amrex::Real r_ratio = R_star/r; amrex::Real r3 = r_ratio*r_ratio*r_ratio; - amrex::Real Er = B_star*omega_star*R_star*r_ratio*r3*(1-3*c_theta*c_theta); + amrex::Real Er = B_star*omega*R_star*r_ratio*r3*(1.0-3.0*c_theta*c_theta); if (E_external_monopole == 1) { - Er += (4.0/3.0)*omega_star*B_star*R_star*r_ratio*r_ratio; + Er += (2.0/3.0)*omega*B_star*R_star*r_ratio*r_ratio; } - amrex::Real Etheta = (-1.0)*B_star*omega_star*R_star*r_ratio*r3*(2*s_theta*c_theta); + amrex::Real Etheta = (-1.0)*B_star*omega*R_star*r_ratio*r3*(2.0*s_theta*c_theta); Exp = Er*s_theta*c_phi + Etheta*c_theta*c_phi; Eyp = Er*s_theta*s_phi + Etheta*c_theta*s_phi; Ezp = Er*c_theta - Etheta*s_theta; - amrex::Real Br = 2*B_star*r3*c_theta; + amrex::Real Br = 2.0*B_star*r3*c_theta; amrex::Real Btheta = B_star*r3*s_theta; Bxp = Br*s_theta*c_phi + Btheta*c_theta*c_phi; diff --git a/Source/Particles/WarpXParticleContainer.H b/Source/Particles/WarpXParticleContainer.H index 6f6eac78e34..d94dfdba826 100644 --- a/Source/Particles/WarpXParticleContainer.H +++ b/Source/Particles/WarpXParticleContainer.H @@ -331,6 +331,7 @@ public: amrex::Array get_v_galilean () {return m_v_galilean;} #ifdef PULSAR virtual void PulsarParticleInjection () {}; + virtual void PulsarParticleRemoval () {}; #endif /** From a2d091f9edf18d8ec853e5395145cc507fd63f37 Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Wed, 22 Jan 2020 14:39:17 -0800 Subject: [PATCH 013/120] add particles based on analytical surface charge density --- .../pulsar/pulsar_viz.ipynb | 66 ++++++++++--------- .../Particles/PhysicalParticleContainer.cpp | 53 +++++++-------- Source/Particles/PulsarParameters.cpp | 10 +-- 3 files changed, 62 insertions(+), 67 deletions(-) diff --git a/Examples/Physics_applications/pulsar/pulsar_viz.ipynb b/Examples/Physics_applications/pulsar/pulsar_viz.ipynb index 514b47ceb5d..44e5536c98a 100644 --- a/Examples/Physics_applications/pulsar/pulsar_viz.ipynb +++ b/Examples/Physics_applications/pulsar/pulsar_viz.ipynb @@ -43,17 +43,19 @@ }, { "cell_type": "code", - "execution_count": 73, + "execution_count": 87, "metadata": {}, "outputs": [], "source": [ - "ds = yt.load( './plotfiles/plt00120/' ) # Create a dataset object\n", + "\n", + "ds = yt.load( './plotfiles/plt00180/' ) # Create a dataset object\n", + "filenum = 180\n", "#ds.field_list" ] }, { "cell_type": "code", - "execution_count": 74, + "execution_count": 88, "metadata": { "scrolled": false }, @@ -69,10 +71,10 @@ { "data": { "text/html": [ - "
" + "
" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -81,10 +83,10 @@ { "data": { "text/plain": [ - "['./particle_in_ring.png']" + "['./particle_in_ring_plt180.png']" ] }, - "execution_count": 74, + "execution_count": 88, "metadata": {}, "output_type": "execute_result" } @@ -96,10 +98,10 @@ "sl.annotate_particles(width=(2.e3, 'm'),ptype=\"plasma_e\",col='r',p_size=5.0)\n", "sl.annotate_streamlines(\"Ey\", \"Ez\", plot_args={\"color\": \"black\"})\n", "sl.annotate_grids() # Show grids\n", - "sl.annotate_sphere([90000.0, 90000.0, 90000.0], radius=12000.0,\n", + "sl.annotate_sphere([90000.0, 90000.0, 90000.0], radius=10500.0,\n", " circle_args={'color':'white', 'linewidth':2})\n", "sl.show() # Show the plot\n", - "sl.save('./particle_in_ring.png')" + "sl.save('./particle_in_ring_plt'+str(filenum)+'.png')" ] }, { @@ -204,7 +206,7 @@ " r_ratio = r_star/r\n", " r3 = r_ratio*r_ratio*r_ratio\n", " Er = omega*r_star*B*r3*r_ratio*(1.0-3.0*c_theta*c_theta) \n", - " #+ (2.0/3.0)*omega*B*r_star*r_ratio*r_ratio\n", + " + (2.0/3.0)*omega*B*r_star*r_ratio*r_ratio\n", " E_theta = (-1)*omega*B*r_star*r3*r_ratio*(c_theta*s_theta*2.0)\n", " Ex_ext = Er*c_phi*s_theta + E_theta*c_phi*c_theta\n", "\n", @@ -278,7 +280,7 @@ " r_ratio = r_star/r\n", " r3 = r_ratio*r_ratio*r_ratio\n", " Er = omega*r_star*B*r3*r_ratio*(1.0-3.0*c_theta*c_theta) \n", - " # + (2.0/3.0)*omega*B*r_star*r_ratio*r_ratio\n", + " + (2.0/3.0)*omega*B*r_star*r_ratio*r_ratio\n", " E_theta = (-1)*omega*B*r_star*r3*r_ratio*(c_theta*s_theta*2.0)\n", " Ey_ext = Er*s_phi*s_theta + E_theta*s_phi*c_theta\n", "\n", @@ -350,7 +352,7 @@ " r_ratio = r_star/r\n", " r3 = r_ratio*r_ratio*r_ratio\n", " Er = omega*r_star*B*r3*r_ratio*(1.0-3.0*c_theta*c_theta) \n", - " # + (2.0/3.0)*omega*B*r_star*r_ratio*r_ratio\n", + " + (2.0/3.0)*omega*B*r_star*r_ratio*r_ratio\n", " E_theta = (-1)*omega*B*r_star*r3*r_ratio*(c_theta*s_theta*2.0)\n", " Ez_ext = Er*c_theta - E_theta*s_theta\n", "\n", @@ -395,8 +397,8 @@ " outside[data[\"rad\"] <= 12000] = 1.0\n", "\n", " \n", - " return outside.d*Ez_ext.d\n", - " # return outside.d*Er.d" + " #return outside.d*Ez_ext.d\n", + " return outside.d*Er.d" ] }, { @@ -457,10 +459,10 @@ { "data": { "text/html": [ - "
" + "
" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -469,10 +471,10 @@ { "data": { "text/html": [ - "
" + "
" ], "text/plain": [ - "" + "" ] }, "execution_count": 17, @@ -491,29 +493,29 @@ "ds.add_field((\"Ey_total_ext\"),function=Ey_total_ext,units='',sampling_type=\"cell\")\n", "ds.add_field((\"Ez_total_ext\"),function=Ez_total_ext,units='',sampling_type=\"cell\")\n", "\n", - "p = yt.SlicePlot(ds,'x','Ez_external')\n", - "p.annotate_streamlines(\"Ey_external\", \"Ez_external\", \n", + "p = yt.SlicePlot(ds,'y','Ez_external')\n", + "p.annotate_streamlines(\"Ex_external\", \"Ez_external\", \n", " plot_args={\"color\": \"black\"})\n", "#p.annotate_particles(width=(2.e3, 'm'),ptype=\"plasma_p\",col='b',p_size=5.0)\n", "#p.annotate_particles(width=(2.e3, 'm'),ptype=\"plasma_e\",col='r',p_size=5.0)\n", "p.show()\n", "p = yt.SlicePlot(ds,'x','Ez_internal')\n", - "p.annotate_streamlines(\"Ey_internal\", \"Ez_internal\", \n", + "p.annotate_streamlines(\"Ex_internal\", \"Ez_internal\", \n", " plot_args={\"color\": \"black\"})" ] }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 89, "metadata": {}, "outputs": [ { "data": { "text/html": [ - "
" + "
" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -522,10 +524,10 @@ { "data": { "text/plain": [ - "['uniform_ring_50ppc.png']" + "['positron_plt180.png']" ] }, - "execution_count": 64, + "execution_count": 89, "metadata": {}, "output_type": "execute_result" } @@ -533,12 +535,12 @@ "source": [ "p = yt.ParticlePlot(ds,('plasma_p', 'particle_position_x'),('plasma_p', 'particle_position_y'),('plasma_p', 'particle_momentum_x'))\n", "p.show()\n", - "p.save(\"uniform_ring_50ppc.png\")" + "p.save(\"positron_plt\"+str(filenum)+\".png\")" ] }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 19, "metadata": { "scrolled": false }, @@ -546,10 +548,10 @@ { "data": { "text/html": [ - "
" + "
" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -561,7 +563,7 @@ "['uniform_ring_50ppc.png']" ] }, - "execution_count": 65, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -570,7 +572,7 @@ "p = yt.ParticlePlot(ds,('plasma_e', 'particle_position_x'),('plasma_e', 'particle_position_y'),('plasma_e', 'particle_momentum_x'))\n", "\n", "p.show()\n", - "p.save(\"uniform_ring_50ppc.png\")" + "p.save(\"electrons_plt\"+str(filenum)+\".png\")" ] }, { diff --git a/Source/Particles/PhysicalParticleContainer.cpp b/Source/Particles/PhysicalParticleContainer.cpp index 6803dec3f29..8c00e524e91 100644 --- a/Source/Particles/PhysicalParticleContainer.cpp +++ b/Source/Particles/PhysicalParticleContainer.cpp @@ -861,7 +861,6 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) continue; } #endif - // Save the x and y values to use in the insideBounds checks. // This is needed with WARPX_DIM_RZ since x and y are modified. Real xb = pos.x; @@ -925,14 +924,14 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) const amrex::Real c_phi = std::cos(cc_phi); const amrex::Real s_phi = std::sin(cc_phi); amrex::Real omega = PulsarParm::omega_star; - if (t < 2.0e-4) { - omega = PulsarParm::omega_star*t/2.0e-4; - } + //if (t < 2.0e-4) { + // omega = PulsarParm::omega_star*t/2.0e-4; + //} amrex::Real ratio = PulsarParm::R_star/cc_rad; amrex::Real r3 = ratio*ratio*ratio; amrex::Real Er_cor = PulsarParm::B_star *omega - *PulsarParm::R_star*s_theta*s_theta; + *cc_rad*s_theta*s_theta; Real Er_ext = omega*PulsarParm::B_star*PulsarParm::R_star *(1.0-3.0*c_theta*c_theta); int ii = Ex_lo.x + iv[0]; @@ -942,33 +941,27 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) Real ey_avg = 0.25*(ex_arr(ii,jj,kk) + ex_arr(ii+1,jj,kk)+ex_arr(ii,jj,kk+1) + ex_arr(ii+1,jj,kk+1)); Real ez_avg = 0.25*(ex_arr(ii,jj,kk) + ex_arr(ii,jj+1,kk)+ex_arr(ii+1,jj,kk) + ex_arr(ii+1,jj+1,kk)); Real Er_cell = ex_avg*s_theta*c_phi + ey_avg*s_theta*s_phi + ez_avg*c_theta; - Real sigma_inj = ((Er_cell - Er_cor)); + Real sigma_inj = ((Er_ext - Er_cor)); Real max_dens = 5.54e6; Real N_inj = 0.2*std::abs(sigma_inj) * dx[0]*dx[0]* 8.85e-12/(1.609e-19*max_dens*scale_fac); - //amrex::Print() << " ex_arr " << ex_avg << " ey avg " << ey_avg << " ez_avg " << ez_avg << " E_cell " << Er_cell << " Er_corr " << Er_cor << " sigma inj " << sigma_inj << " ninj " << N_inj << " num pcc " << num_ppc << " dt " << dt << " t " << t << "\n"; - // amrex::Print() << " ex_arr " << ex_avg << " ey avg " << ey_avg << " ez_avg " << ez_avg << " Er_cell " << Er_cell << " Er ext " << Er_ext << " Er_corr " << Er_cor << " sigma inj " << sigma_inj << " ninj " << N_inj << " num pcc " << num_ppc << " ccrad " << cc_rad << " t "<< t << "\n"; - if (t > 0) { - if (N_inj >= 1) { - int part_freq = floor(num_ppc / N_inj); - if (N_inj < num_ppc) { - if (i_part%part_freq!=0) { - p.id() = -1; - continue; - } - } - } - else - { - p.id() = -1; - continue; - } - } - ////if (N_inj < 1) { p.id() = -1; return;} - //if (t > 0) { - // if (sigma_inj < 0 and q_pm >0) {p.id()=-1; return;} - // if (sigma_inj > 0 and q_pm <0) {p.id()=-1; return;} - //} - + if (t > 0) { + if (N_inj >= 1) { + if (N_inj < num_ppc) { + int part_freq = floor(num_ppc / N_inj); + if (i_part%part_freq!=0) { + p.id() = -1; + continue; + } + } + } + else + { + p.id() = -1; + continue; + } + if (sigma_inj < 0 and q_pm >0) {p.id()=-1; continue;} + if (sigma_inj > 0 and q_pm <0) {p.id()=-1; continue;} + } #endif u = inj_mom->getMomentum(pos.x, pos.y, z0, engine); diff --git a/Source/Particles/PulsarParameters.cpp b/Source/Particles/PulsarParameters.cpp index 748af9a3559..6ec1534c944 100644 --- a/Source/Particles/PulsarParameters.cpp +++ b/Source/Particles/PulsarParameters.cpp @@ -53,12 +53,12 @@ namespace PulsarParm const amrex::Real c_phi = std::cos(phi); const amrex::Real s_phi = std::sin(phi); amrex::Real omega = omega_star; - if (time < 2.0e-4) { - omega = omega_star*time/2.0e-4; - } + //if (time < 2.0e-4) { + // omega = omega_star*time/2.0e-4; + //} // Inside star :: uniform B a,d E = - (omega X r) X B - if (r= R_star) { + if (r >= R_star - PulsarParm::dR_star) { amrex::Real r_ratio = R_star/r; amrex::Real r3 = r_ratio*r_ratio*r_ratio; amrex::Real Er = B_star*omega*R_star*r_ratio*r3*(1.0-3.0*c_theta*c_theta); From 1072fbe48fcb136c6a7ae6a38abcef174b2408d1 Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Wed, 22 Jan 2020 16:07:12 -0800 Subject: [PATCH 014/120] using local Er and Er_cor to compute particle introduction --- .../pulsar/inputs.corotating.3d.PM | 13 +++-- .../pulsar/pulsar_viz.ipynb | 28 ++++----- Source/Evolve/WarpXEvolve.cpp | 6 ++ .../Particles/PhysicalParticleContainer.cpp | 58 +++++++++++++------ Source/Particles/PulsarParameters.cpp | 4 +- 5 files changed, 68 insertions(+), 41 deletions(-) diff --git a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM index 8df4ef4e50f..2fdbb560132 100644 --- a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM +++ b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM @@ -76,8 +76,8 @@ plasma_e.num_particles_per_cell_each_dim = 3 3 3 plasma_e.momentum_distribution_type = parse_momentum_function #plasma_e.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*(-( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" #plasma_e.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*( ( (t=to)*omega ) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" -##plasma_e.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(-omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" -##plasma_e.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" +#plasma_e.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(-omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" +#plasma_e.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" plasma_e.momentum_function_uz(x,y,z) = "0.0" plasma_e.momentum_function_ux(x,y,z) = "0.0" plasma_e.momentum_function_uy(x,y,z) = "0.0" @@ -100,11 +100,12 @@ plasma_p.momentum_distribution_type = parse_momentum_function #plasma_p.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" #plasma_p.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*(-( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" #plasma_p.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*( ( (t=to)*omega ) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" -##plasma_p.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(-omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" -##plasma_p.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" +#plasma_p.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(-omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" +#plasma_p.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" plasma_p.momentum_function_uz(x,y,z) = "0.0" -plasma_p.momentum_function_uz(x,y,z) = "0.0" -plasma_p.momentum_distribution_type = "constant" +plasma_p.momentum_function_ux(x,y,z) = "0.0" +plasma_p.momentum_function_uy(x,y,z) = "0.0" +#plasma_p.momentum_distribution_type = "constant" #plasma_p.ux = 0.0 #plasma_p.uy = 0.0 #plasma_p.uz = 0.0 diff --git a/Examples/Physics_applications/pulsar/pulsar_viz.ipynb b/Examples/Physics_applications/pulsar/pulsar_viz.ipynb index 44e5536c98a..b7dbca2ce43 100644 --- a/Examples/Physics_applications/pulsar/pulsar_viz.ipynb +++ b/Examples/Physics_applications/pulsar/pulsar_viz.ipynb @@ -43,19 +43,19 @@ }, { "cell_type": "code", - "execution_count": 87, + "execution_count": 151, "metadata": {}, "outputs": [], "source": [ "\n", - "ds = yt.load( './plotfiles/plt00180/' ) # Create a dataset object\n", - "filenum = 180\n", + "ds = yt.load( './plotfiles/plt00040/' ) # Create a dataset object\n", + "filenum = 10\n", "#ds.field_list" ] }, { "cell_type": "code", - "execution_count": 88, + "execution_count": 152, "metadata": { "scrolled": false }, @@ -71,10 +71,10 @@ { "data": { "text/html": [ - "
" + "
" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -83,10 +83,10 @@ { "data": { "text/plain": [ - "['./particle_in_ring_plt180.png']" + "['./particle_in_ring_plt10.png']" ] }, - "execution_count": 88, + "execution_count": 152, "metadata": {}, "output_type": "execute_result" } @@ -98,7 +98,7 @@ "sl.annotate_particles(width=(2.e3, 'm'),ptype=\"plasma_e\",col='r',p_size=5.0)\n", "sl.annotate_streamlines(\"Ey\", \"Ez\", plot_args={\"color\": \"black\"})\n", "sl.annotate_grids() # Show grids\n", - "sl.annotate_sphere([90000.0, 90000.0, 90000.0], radius=10500.0,\n", + "sl.annotate_sphere([90000.0, 90000.0, 90000.0], radius=12000.0,\n", " circle_args={'color':'white', 'linewidth':2})\n", "sl.show() # Show the plot\n", "sl.save('./particle_in_ring_plt'+str(filenum)+'.png')" @@ -506,16 +506,16 @@ }, { "cell_type": "code", - "execution_count": 89, + "execution_count": 140, "metadata": {}, "outputs": [ { "data": { "text/html": [ - "
" + "
" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -524,10 +524,10 @@ { "data": { "text/plain": [ - "['positron_plt180.png']" + "['positron_plt30.png']" ] }, - "execution_count": 89, + "execution_count": 140, "metadata": {}, "output_type": "execute_result" } diff --git a/Source/Evolve/WarpXEvolve.cpp b/Source/Evolve/WarpXEvolve.cpp index 8854384dc10..ef60380cccc 100644 --- a/Source/Evolve/WarpXEvolve.cpp +++ b/Source/Evolve/WarpXEvolve.cpp @@ -205,6 +205,12 @@ WarpX::Evolve (int numsteps) int num_moved = MoveWindow(move_j); #ifdef PULSAR + if (!rho_fp[0]) { + amrex::Print() << " no rho -- compute rho! \n"; + } + else { + amrex::Print() << " rho is computed \n"; + } mypc->PulsarParticleRemoval(); mypc->PulsarParticleInjection(); #endif diff --git a/Source/Particles/PhysicalParticleContainer.cpp b/Source/Particles/PhysicalParticleContainer.cpp index 8c00e524e91..7972766b98c 100644 --- a/Source/Particles/PhysicalParticleContainer.cpp +++ b/Source/Particles/PhysicalParticleContainer.cpp @@ -626,6 +626,7 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) const MultiFab& Ex_mf = WarpX::GetInstance().getEfield(lev,0); const MultiFab& Ey_mf = WarpX::GetInstance().getEfield(lev,1); const MultiFab& Ez_mf = WarpX::GetInstance().getEfield(lev,2); + const MultiFab& rho_mf = WarpX::GetInstance().getRho(lev); const Real dt = WarpX::GetInstance().getdt(0); // if (t > 100*dt) {return;} #endif @@ -812,12 +813,14 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) const FArrayBox& Ex_fab = Ex_mf[mfi]; const FArrayBox& Ey_fab = Ey_mf[mfi]; const FArrayBox& Ez_fab = Ez_mf[mfi]; + const FArrayBox& rho_fab = rho_mf[mfi]; const Dim3 Ex_lo = lbound(mfi.tilebox()); const Dim3 Ey_lo = lbound(mfi.tilebox()); const Dim3 Ez_lo = lbound(mfi.tilebox()); amrex::Array4 const& ex_arr = Ex_fab.array(); amrex::Array4 const& ey_arr = Ey_fab.array(); amrex::Array4 const& ez_arr = Ez_fab.array(); + amrex::Array4 const& rho_arr = rho_fab.array(); const Real q_pm = this->charge; //amrex::Print() << " box " << x_box << "\n"; //FArrayBox Ey_fab = Ey_mf[mfi]; @@ -934,6 +937,9 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) *cc_rad*s_theta*s_theta; Real Er_ext = omega*PulsarParm::B_star*PulsarParm::R_star *(1.0-3.0*c_theta*c_theta); + Er_ext += (2.0/3.0)*omega*PulsarParm::B_star*PulsarParm::R_star; + amrex::Real rho_GJ = 2*8.85e-12*PulsarParm::B_star*omega + *PulsarParm::R_star*(1.0-3.0*c_theta*c_theta); int ii = Ex_lo.x + iv[0]; int jj = Ex_lo.y + iv[1]; int kk = Ex_lo.z + iv[2]; @@ -941,27 +947,41 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) Real ey_avg = 0.25*(ex_arr(ii,jj,kk) + ex_arr(ii+1,jj,kk)+ex_arr(ii,jj,kk+1) + ex_arr(ii+1,jj,kk+1)); Real ez_avg = 0.25*(ex_arr(ii,jj,kk) + ex_arr(ii,jj+1,kk)+ex_arr(ii+1,jj,kk) + ex_arr(ii+1,jj+1,kk)); Real Er_cell = ex_avg*s_theta*c_phi + ey_avg*s_theta*s_phi + ez_avg*c_theta; - Real sigma_inj = ((Er_ext - Er_cor)); + Real sigma_inj = ((Er_ext + Er_cell - Er_cor)); Real max_dens = 5.54e6; Real N_inj = 0.2*std::abs(sigma_inj) * dx[0]*dx[0]* 8.85e-12/(1.609e-19*max_dens*scale_fac); - if (t > 0) { - if (N_inj >= 1) { - if (N_inj < num_ppc) { - int part_freq = floor(num_ppc / N_inj); - if (i_part%part_freq!=0) { - p.id() = -1; - continue; - } - } - } - else - { - p.id() = -1; - continue; - } - if (sigma_inj < 0 and q_pm >0) {p.id()=-1; continue;} - if (sigma_inj > 0 and q_pm <0) {p.id()=-1; continue;} - } + if (t > 0) { + if (N_inj >= 1) { + if (N_inj < num_ppc) { + int part_freq = floor(num_ppc / N_inj); + if (i_part%part_freq!=0) { + p.id() = -1; + continue; + } + } + } + else + { + p.id() = -1; + continue; + } + //if (sigma_inj < 0 and q_pm >0) {p.id()=-1; return;} + //if (sigma_inj > 0 and q_pm <0) {p.id()=-1; return;} + if (rho_GJ == 0) { + amrex::Print() << " rho is " << rho_arr(ii,jj,kk) << " rho_GJ " << rho_GJ << " rho gj is zero \n"; + p.id() = -1; + return; + } + else { + Real rel_rho_err = std::abs((rho_arr(ii,jj,kk) - rho_GJ)/rho_GJ); + amrex::Print() << " rho is " << rho_arr(ii,jj,kk) << " rho_GJ " << rho_GJ << " rel err : " << rel_rho_err << "\n"; + amrex::Print() << " Er_Cell " << Er_cell << " " << " Er_Ext " << Er_ext <<" Er cor " << Er_cor << "\n"; + if ( rel_rho_err < 0.1) { + p.id() = -1; + return; + } + } + } #endif u = inj_mom->getMomentum(pos.x, pos.y, z0, engine); diff --git a/Source/Particles/PulsarParameters.cpp b/Source/Particles/PulsarParameters.cpp index 6ec1534c944..ffb632a3e19 100644 --- a/Source/Particles/PulsarParameters.cpp +++ b/Source/Particles/PulsarParameters.cpp @@ -58,7 +58,7 @@ namespace PulsarParm //} // Inside star :: uniform B a,d E = - (omega X r) X B - if (r= R_star - PulsarParm::dR_star) { + if (r >= R_star) { amrex::Real r_ratio = R_star/r; amrex::Real r3 = r_ratio*r_ratio*r_ratio; amrex::Real Er = B_star*omega*R_star*r_ratio*r3*(1.0-3.0*c_theta*c_theta); From c911e9f914ce8135a961ca374ca3c172eedb6eda Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Wed, 22 Jan 2020 16:13:14 -0800 Subject: [PATCH 015/120] fixing particle injection with local Er that includes Er_external --- .../Physics_applications/pulsar/pulsar_viz.ipynb | 12 ++++++------ Source/Particles/PhysicalParticleContainer.cpp | 10 +++++----- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/Examples/Physics_applications/pulsar/pulsar_viz.ipynb b/Examples/Physics_applications/pulsar/pulsar_viz.ipynb index b7dbca2ce43..946266afb7a 100644 --- a/Examples/Physics_applications/pulsar/pulsar_viz.ipynb +++ b/Examples/Physics_applications/pulsar/pulsar_viz.ipynb @@ -43,19 +43,19 @@ }, { "cell_type": "code", - "execution_count": 151, + "execution_count": 153, "metadata": {}, "outputs": [], "source": [ "\n", - "ds = yt.load( './plotfiles/plt00040/' ) # Create a dataset object\n", + "ds = yt.load( './plotfiles/plt00120/' ) # Create a dataset object\n", "filenum = 10\n", "#ds.field_list" ] }, { "cell_type": "code", - "execution_count": 152, + "execution_count": 154, "metadata": { "scrolled": false }, @@ -71,10 +71,10 @@ { "data": { "text/html": [ - "
" + "
" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -86,7 +86,7 @@ "['./particle_in_ring_plt10.png']" ] }, - "execution_count": 152, + "execution_count": 154, "metadata": {}, "output_type": "execute_result" } diff --git a/Source/Particles/PhysicalParticleContainer.cpp b/Source/Particles/PhysicalParticleContainer.cpp index 7972766b98c..a8c6f8ba20b 100644 --- a/Source/Particles/PhysicalParticleContainer.cpp +++ b/Source/Particles/PhysicalParticleContainer.cpp @@ -968,17 +968,17 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) //if (sigma_inj < 0 and q_pm >0) {p.id()=-1; return;} //if (sigma_inj > 0 and q_pm <0) {p.id()=-1; return;} if (rho_GJ == 0) { - amrex::Print() << " rho is " << rho_arr(ii,jj,kk) << " rho_GJ " << rho_GJ << " rho gj is zero \n"; + // amrex::Print() << " rho is " << rho_arr(ii,jj,kk) << " rho_GJ " << rho_GJ << " rho gj is zero \n"; p.id() = -1; - return; + continue; } else { Real rel_rho_err = std::abs((rho_arr(ii,jj,kk) - rho_GJ)/rho_GJ); - amrex::Print() << " rho is " << rho_arr(ii,jj,kk) << " rho_GJ " << rho_GJ << " rel err : " << rel_rho_err << "\n"; - amrex::Print() << " Er_Cell " << Er_cell << " " << " Er_Ext " << Er_ext <<" Er cor " << Er_cor << "\n"; + //amrex::Print() << " rho is " << rho_arr(ii,jj,kk) << " rho_GJ " << rho_GJ << " rel err : " << rel_rho_err << "\n"; + //amrex::Print() << " Er_Cell " << Er_cell << " " << " Er_Ext " << Er_ext <<" Er cor " << Er_cor << "\n"; if ( rel_rho_err < 0.1) { p.id() = -1; - return; + continue; } } } From 3fe5f397ad2cca72fb1e8e1f5b0858821d5c598e Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Wed, 22 Jan 2020 20:18:36 -0800 Subject: [PATCH 016/120] changes to pulsar --- .../pulsar/inputs.corotating.3d.PM | 12 +- .../pulsar/pulsar_viz.ipynb | 185 +++++++++--------- .../Particles/PhysicalParticleContainer.cpp | 2 +- Source/Particles/PulsarParameters.cpp | 3 +- 4 files changed, 101 insertions(+), 101 deletions(-) diff --git a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM index 2fdbb560132..0ae61056e56 100644 --- a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM +++ b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM @@ -72,7 +72,7 @@ plasma_e.injection_style = "NUniformPerCell" plasma_e.profile = parse_density_function #plasma_e.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star) * ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<(r_star+dR)) )*dens" plasma_e.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star) * ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=(r_star-dR)) )*dens" -plasma_e.num_particles_per_cell_each_dim = 3 3 3 +plasma_e.num_particles_per_cell_each_dim = 4 4 4 plasma_e.momentum_distribution_type = parse_momentum_function #plasma_e.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*(-( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" #plasma_e.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*( ( (t=to)*omega ) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" @@ -81,10 +81,6 @@ plasma_e.momentum_distribution_type = parse_momentum_function plasma_e.momentum_function_uz(x,y,z) = "0.0" plasma_e.momentum_function_ux(x,y,z) = "0.0" plasma_e.momentum_function_uy(x,y,z) = "0.0" -#plasma_e.momentum_distribution_type = "constant" -#plasma_e.ux = 0.0 -#plasma_e.uy = 0.0 -#plasma_e.uz = 0.0 plasma_e.do_continuous_injection = 0 plasma_e.density_min = 1E0 @@ -94,7 +90,7 @@ plasma_p.injection_style = "NUniformPerCell" plasma_p.profile = parse_density_function #plasma_p.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)* ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<(r_star+dR)))*dens" plasma_p.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star) * ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=(r_star-dR)) )*dens" -plasma_p.num_particles_per_cell_each_dim = 3 3 3 +plasma_p.num_particles_per_cell_each_dim = 4 4 4 plasma_p.momentum_distribution_type = parse_momentum_function #plasma_p.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*(-omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" #plasma_p.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" @@ -105,10 +101,6 @@ plasma_p.momentum_distribution_type = parse_momentum_function plasma_p.momentum_function_uz(x,y,z) = "0.0" plasma_p.momentum_function_ux(x,y,z) = "0.0" plasma_p.momentum_function_uy(x,y,z) = "0.0" -#plasma_p.momentum_distribution_type = "constant" -#plasma_p.ux = 0.0 -#plasma_p.uy = 0.0 -#plasma_p.uz = 0.0 plasma_p.do_continuous_injection = 0 plasma_p.density_min = 1E0 diff --git a/Examples/Physics_applications/pulsar/pulsar_viz.ipynb b/Examples/Physics_applications/pulsar/pulsar_viz.ipynb index 946266afb7a..3f540ebad7f 100644 --- a/Examples/Physics_applications/pulsar/pulsar_viz.ipynb +++ b/Examples/Physics_applications/pulsar/pulsar_viz.ipynb @@ -43,19 +43,19 @@ }, { "cell_type": "code", - "execution_count": 153, + "execution_count": 57, "metadata": {}, "outputs": [], "source": [ "\n", - "ds = yt.load( './plotfiles/plt00120/' ) # Create a dataset object\n", + "ds = yt.load( './plotfiles/plt00060/' ) # Create a dataset object\n", "filenum = 10\n", "#ds.field_list" ] }, { "cell_type": "code", - "execution_count": 154, + "execution_count": 58, "metadata": { "scrolled": false }, @@ -71,10 +71,10 @@ { "data": { "text/html": [ - "
" + "
" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -86,7 +86,7 @@ "['./particle_in_ring_plt10.png']" ] }, - "execution_count": 154, + "execution_count": 58, "metadata": {}, "output_type": "execute_result" } @@ -106,14 +106,76 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 55, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/html": [ + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "['positron_plt10.png']" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p = yt.ParticlePlot(ds,('plasma_p', 'particle_position_x'),('plasma_p', 'particle_position_y'),('plasma_p', 'particle_momentum_z'))\n", + "p.show()\n", + "p.save(\"positron_plt\"+str(filenum)+\".png\")" + ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "['electrons_plt10.png']" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p = yt.ParticlePlot(ds,('plasma_e', 'particle_position_y'),('plasma_e', 'particle_position_z'),('plasma_e', 'particle_momentum_y'))\n", + "#p = yt.ParticlePlot(ds,('plasma_p', 'particle_position_y'),('plasma_p', 'particle_position_z'),('plasma_p', 'particle_momentum_x'))\n", + "p.show()\n", + "p.save(\"electrons_plt\"+str(filenum)+\".png\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -134,7 +196,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -144,7 +206,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -165,7 +227,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -182,7 +244,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -219,7 +281,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -255,7 +317,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -293,7 +355,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -328,7 +390,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -366,7 +428,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -403,7 +465,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -419,7 +481,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -435,7 +497,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -451,7 +513,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 24, "metadata": { "scrolled": false }, @@ -459,10 +521,10 @@ { "data": { "text/html": [ - "
" + "
" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -474,10 +536,10 @@ "
" ], "text/plain": [ - "" + "" ] }, - "execution_count": 17, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -493,7 +555,7 @@ "ds.add_field((\"Ey_total_ext\"),function=Ey_total_ext,units='',sampling_type=\"cell\")\n", "ds.add_field((\"Ez_total_ext\"),function=Ez_total_ext,units='',sampling_type=\"cell\")\n", "\n", - "p = yt.SlicePlot(ds,'y','Ez_external')\n", + "p = yt.SlicePlot(ds,'x','Ey_external')\n", "p.annotate_streamlines(\"Ex_external\", \"Ez_external\", \n", " plot_args={\"color\": \"black\"})\n", "#p.annotate_particles(width=(2.e3, 'm'),ptype=\"plasma_p\",col='b',p_size=5.0)\n", @@ -506,74 +568,19 @@ }, { "cell_type": "code", - "execution_count": 140, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "['positron_plt30.png']" - ] - }, - "execution_count": 140, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "p = yt.ParticlePlot(ds,('plasma_p', 'particle_position_x'),('plasma_p', 'particle_position_y'),('plasma_p', 'particle_momentum_x'))\n", - "p.show()\n", - "p.save(\"positron_plt\"+str(filenum)+\".png\")" - ] + "outputs": [], + "source": [] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": { "scrolled": false }, - "outputs": [ - { - "data": { - "text/html": [ - "
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "['uniform_ring_50ppc.png']" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "p = yt.ParticlePlot(ds,('plasma_e', 'particle_position_x'),('plasma_e', 'particle_position_y'),('plasma_e', 'particle_momentum_x'))\n", - "\n", - "p.show()\n", - "p.save(\"electrons_plt\"+str(filenum)+\".png\")" - ] + "outputs": [], + "source": [] }, { "cell_type": "code", diff --git a/Source/Particles/PhysicalParticleContainer.cpp b/Source/Particles/PhysicalParticleContainer.cpp index a8c6f8ba20b..70fb8660739 100644 --- a/Source/Particles/PhysicalParticleContainer.cpp +++ b/Source/Particles/PhysicalParticleContainer.cpp @@ -2275,7 +2275,7 @@ void PhysicalParticleContainer::PulsarParticleRemoval() { Real r = std::sqrt((xp_data[i]-xc)*(xp_data[i]-xc) + (yp_data[i]-yc)*(yp_data[i]-yc) + (zp_data[i]-zc)*(zp_data[i]-zc)); - if (r<=PulsarParm::R_star - PulsarParm::dR_star) { + if (r<=(PulsarParm::R_star-PulsarParm::dR_star)) { pp[i].id() = -1; } }); diff --git a/Source/Particles/PulsarParameters.cpp b/Source/Particles/PulsarParameters.cpp index ffb632a3e19..e85daeaea27 100644 --- a/Source/Particles/PulsarParameters.cpp +++ b/Source/Particles/PulsarParameters.cpp @@ -56,6 +56,7 @@ namespace PulsarParm //if (time < 2.0e-4) { // omega = omega_star*time/2.0e-4; //} + Exp = 0.0; Eyp = 0.0; Ezp = 0.0; // Inside star :: uniform B a,d E = - (omega X r) X B if (r= R_star) { + if (r >= R_star - PulsarParm::dR_star) { amrex::Real r_ratio = R_star/r; amrex::Real r3 = r_ratio*r_ratio*r_ratio; amrex::Real Er = B_star*omega*R_star*r_ratio*r3*(1.0-3.0*c_theta*c_theta); From 3a13a42b84b00a077acdb1c991e126948c0cf80f Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Thu, 23 Jan 2020 15:18:23 -0800 Subject: [PATCH 017/120] michel and li efields inside and outside star. Particle injection rho_GJ --- .../pulsar/inputs.corotating.3d.PM | 16 +-- .../pulsar/pulsar_viz.ipynb | 134 +++++------------- .../Particles/PhysicalParticleContainer.cpp | 14 +- Source/Particles/PulsarParameters.cpp | 24 ++-- 4 files changed, 67 insertions(+), 121 deletions(-) diff --git a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM index 0ae61056e56..53939bff527 100644 --- a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM +++ b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM @@ -45,7 +45,7 @@ my_constants.r_star = 12000 my_constants.omega = 6245.676 my_constants.c = 299792458. my_constants.B_star = 8.0323e-6 # magnetic field of NS (T) -my_constants.dR = 2e3 +my_constants.dR = 1.4e3 my_constants.to = -2e-4 interpolation.nox = 3 interpolation.noy = 3 @@ -72,10 +72,10 @@ plasma_e.injection_style = "NUniformPerCell" plasma_e.profile = parse_density_function #plasma_e.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star) * ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<(r_star+dR)) )*dens" plasma_e.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star) * ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=(r_star-dR)) )*dens" -plasma_e.num_particles_per_cell_each_dim = 4 4 4 +plasma_e.num_particles_per_cell_each_dim = 3 3 3 plasma_e.momentum_distribution_type = parse_momentum_function -#plasma_e.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*(-( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" -#plasma_e.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*( ( (t=to)*omega ) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" +#plasma_e.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(-( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" +#plasma_e.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*( ( (t=to)*omega ) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" #plasma_e.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(-omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" #plasma_e.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" plasma_e.momentum_function_uz(x,y,z) = "0.0" @@ -90,10 +90,10 @@ plasma_p.injection_style = "NUniformPerCell" plasma_p.profile = parse_density_function #plasma_p.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)* ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<(r_star+dR)))*dens" plasma_p.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star) * ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=(r_star-dR)) )*dens" -plasma_p.num_particles_per_cell_each_dim = 4 4 4 +plasma_p.num_particles_per_cell_each_dim = 3 3 3 plasma_p.momentum_distribution_type = parse_momentum_function -#plasma_p.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*(-omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" -#plasma_p.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" +#plasma_p.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(-omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" +#plasma_p.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" #plasma_p.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*(-( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" #plasma_p.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*( ( (t=to)*omega ) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" #plasma_p.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(-omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" @@ -113,7 +113,7 @@ pulsar.omega_star = 6245.676 # angular velocity of NS (rad/s) pulsar.center_star = 90000 90000 90000 pulsar.R_star = 12.e3 # radius of NS (m) pulsar.B_star = 8.0323e-6 # magnetic field of NS (T) -pulsar.dR = 2e3 +pulsar.dR = 1.4e3 pulsar.verbose = 0 # [0/1]: turn on verbosity for debugging print statements pulsar.EB_external = 1 # [0/1]: to apply external E and B pulsar.E_external_monopole = 1 # [0/1] diff --git a/Examples/Physics_applications/pulsar/pulsar_viz.ipynb b/Examples/Physics_applications/pulsar/pulsar_viz.ipynb index 3f540ebad7f..57ef79c1599 100644 --- a/Examples/Physics_applications/pulsar/pulsar_viz.ipynb +++ b/Examples/Physics_applications/pulsar/pulsar_viz.ipynb @@ -43,19 +43,19 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 149, "metadata": {}, "outputs": [], "source": [ "\n", - "ds = yt.load( './plotfiles/plt00060/' ) # Create a dataset object\n", + "ds = yt.load( './plotfiles/plt00090/' ) # Create a dataset object\n", "filenum = 10\n", "#ds.field_list" ] }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 150, "metadata": { "scrolled": false }, @@ -71,24 +71,14 @@ { "data": { "text/html": [ - "
" + "
" ], "text/plain": [ - "" + "" ] }, "metadata": {}, "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "['./particle_in_ring_plt10.png']" - ] - }, - "execution_count": 58, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ @@ -101,21 +91,21 @@ "sl.annotate_sphere([90000.0, 90000.0, 90000.0], radius=12000.0,\n", " circle_args={'color':'white', 'linewidth':2})\n", "sl.show() # Show the plot\n", - "sl.save('./particle_in_ring_plt'+str(filenum)+'.png')" + "#sl.save('./particle_in_ring_plt'+str(filenum)+'.png')" ] }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 147, "metadata": {}, "outputs": [ { "data": { "text/html": [ - "
" + "
" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -127,29 +117,29 @@ "['positron_plt10.png']" ] }, - "execution_count": 55, + "execution_count": 147, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "p = yt.ParticlePlot(ds,('plasma_p', 'particle_position_x'),('plasma_p', 'particle_position_y'),('plasma_p', 'particle_momentum_z'))\n", + "p = yt.ParticlePlot(ds,('plasma_p', 'particle_position_x'),('plasma_p', 'particle_position_y'),('plasma_p', 'particle_momentum_x'))\n", "p.show()\n", "p.save(\"positron_plt\"+str(filenum)+\".png\")" ] }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 148, "metadata": {}, "outputs": [ { "data": { "text/html": [ - "
" + "
" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -161,13 +151,13 @@ "['electrons_plt10.png']" ] }, - "execution_count": 59, + "execution_count": 148, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "p = yt.ParticlePlot(ds,('plasma_e', 'particle_position_y'),('plasma_e', 'particle_position_z'),('plasma_e', 'particle_momentum_y'))\n", + "p = yt.ParticlePlot(ds,('plasma_e', 'particle_position_y'),('plasma_e', 'particle_position_z'),('plasma_e', 'particle_momentum_z'))\n", "#p = yt.ParticlePlot(ds,('plasma_p', 'particle_position_y'),('plasma_p', 'particle_position_z'),('plasma_p', 'particle_momentum_x'))\n", "p.show()\n", "p.save(\"electrons_plt\"+str(filenum)+\".png\")" @@ -175,7 +165,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -196,7 +186,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -206,7 +196,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -227,7 +217,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -244,7 +234,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -281,7 +271,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -317,7 +307,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -355,7 +345,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -390,7 +380,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -428,7 +418,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -465,7 +455,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -481,7 +471,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -497,7 +487,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -513,37 +503,11 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": { "scrolled": false }, - "outputs": [ - { - "data": { - "text/html": [ - "
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "ds.add_field((\"Ex_external\"),function=Ex_external,units='',sampling_type=\"cell\")\n", "ds.add_field((\"Ey_external\"),function=Ey_external,units='',sampling_type=\"cell\")\n", @@ -555,7 +519,7 @@ "ds.add_field((\"Ey_total_ext\"),function=Ey_total_ext,units='',sampling_type=\"cell\")\n", "ds.add_field((\"Ez_total_ext\"),function=Ez_total_ext,units='',sampling_type=\"cell\")\n", "\n", - "p = yt.SlicePlot(ds,'x','Ey_external')\n", + "p = yt.SlicePlot(ds,'x','Ez_external')\n", "p.annotate_streamlines(\"Ex_external\", \"Ez_external\", \n", " plot_args={\"color\": \"black\"})\n", "#p.annotate_particles(width=(2.e3, 'm'),ptype=\"plasma_p\",col='b',p_size=5.0)\n", @@ -601,7 +565,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -612,7 +576,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -665,40 +629,18 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "9800000000000.0" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "5e6*1400*1400" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1343987680000" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "685708*1400*1400" ] diff --git a/Source/Particles/PhysicalParticleContainer.cpp b/Source/Particles/PhysicalParticleContainer.cpp index 70fb8660739..ae8491621c7 100644 --- a/Source/Particles/PhysicalParticleContainer.cpp +++ b/Source/Particles/PhysicalParticleContainer.cpp @@ -947,9 +947,14 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) Real ey_avg = 0.25*(ex_arr(ii,jj,kk) + ex_arr(ii+1,jj,kk)+ex_arr(ii,jj,kk+1) + ex_arr(ii+1,jj,kk+1)); Real ez_avg = 0.25*(ex_arr(ii,jj,kk) + ex_arr(ii,jj+1,kk)+ex_arr(ii+1,jj,kk) + ex_arr(ii+1,jj+1,kk)); Real Er_cell = ex_avg*s_theta*c_phi + ey_avg*s_theta*s_phi + ez_avg*c_theta; - Real sigma_inj = ((Er_ext + Er_cell - Er_cor)); + // analytical surface charge density + Real sigma_inj = PhysConst::ep0*(( Er_ext - Er_cor)); + // hard-coded input parameter -- ndenx = max_dens Real max_dens = 5.54e6; - Real N_inj = 0.2*std::abs(sigma_inj) * dx[0]*dx[0]* 8.85e-12/(1.609e-19*max_dens*scale_fac); + // hard-coded fraction of particles injected + amrex::Real fraction = 0.05; + // number of particle pairs injected + Real N_inj = fraction*std::abs(sigma_inj) * dx[0]*dx[0]/(PhysConst::q_e*max_dens*scale_fac); if (t > 0) { if (N_inj >= 1) { if (N_inj < num_ppc) { @@ -967,7 +972,8 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) } //if (sigma_inj < 0 and q_pm >0) {p.id()=-1; return;} //if (sigma_inj > 0 and q_pm <0) {p.id()=-1; return;} - if (rho_GJ == 0) { + // if rho is too smal -- we dont inject particles + if (std::abs(rho_GJ) < 1E-25) { // amrex::Print() << " rho is " << rho_arr(ii,jj,kk) << " rho_GJ " << rho_GJ << " rho gj is zero \n"; p.id() = -1; continue; @@ -976,7 +982,7 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) Real rel_rho_err = std::abs((rho_arr(ii,jj,kk) - rho_GJ)/rho_GJ); //amrex::Print() << " rho is " << rho_arr(ii,jj,kk) << " rho_GJ " << rho_GJ << " rel err : " << rel_rho_err << "\n"; //amrex::Print() << " Er_Cell " << Er_cell << " " << " Er_Ext " << Er_ext <<" Er cor " << Er_cor << "\n"; - if ( rel_rho_err < 0.1) { + if ( rel_rho_err < 0.3) { p.id() = -1; continue; } diff --git a/Source/Particles/PulsarParameters.cpp b/Source/Particles/PulsarParameters.cpp index e85daeaea27..fd3f661d388 100644 --- a/Source/Particles/PulsarParameters.cpp +++ b/Source/Particles/PulsarParameters.cpp @@ -53,25 +53,22 @@ namespace PulsarParm const amrex::Real c_phi = std::cos(phi); const amrex::Real s_phi = std::sin(phi); amrex::Real omega = omega_star; - //if (time < 2.0e-4) { - // omega = omega_star*time/2.0e-4; - //} - Exp = 0.0; Eyp = 0.0; Ezp = 0.0; + // ramping up omega + if (time < 2.0e-4) { + omega = omega_star*time/2.0e-4; + } - // Inside star :: uniform B a,d E = - (omega X r) X B if (r= R_star - PulsarParm::dR_star) { + if (r >= R_star ) { amrex::Real r_ratio = R_star/r; amrex::Real r3 = r_ratio*r_ratio*r_ratio; + // Taking derivative of phi given in eq 30 of Michel and Li amrex::Real Er = B_star*omega*R_star*r_ratio*r3*(1.0-3.0*c_theta*c_theta); if (E_external_monopole == 1) { Er += (2.0/3.0)*omega*B_star*R_star*r_ratio*r_ratio; From fb941243204ed453d4cb4b720d95cc0bd2f9066d Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Wed, 22 Jan 2020 08:52:21 -0800 Subject: [PATCH 018/120] making changes suggested in the review --- Source/Particles/PulsarParameters.H | 4 +++- Source/Particles/PulsarParameters.cpp | 8 ++++++-- 2 files changed, 9 insertions(+), 3 deletions(-) diff --git a/Source/Particles/PulsarParameters.H b/Source/Particles/PulsarParameters.H index 17953a4ff81..61b3dbe63f3 100644 --- a/Source/Particles/PulsarParameters.H +++ b/Source/Particles/PulsarParameters.H @@ -15,11 +15,13 @@ namespace PulsarParm extern AMREX_GPU_DEVICE_MANAGED amrex::Real dR_star; extern AMREX_GPU_DEVICE_MANAGED int EB_external; extern AMREX_GPU_DEVICE_MANAGED int E_external_monopole; - extern AMREX_GPU_DEVICE_MANAGED amrex::Vector center_star; + extern AMREX_GPU_DEVICE_MANAGED + amrex::GpuArray center_star; extern AMREX_GPU_DEVICE_MANAGED int verbose; void ReadParameters(); + AMREX_GPU_HOST_DEVICE AMREX_INLINE void PulsarEBField(amrex::Real xp, amrex::Real yp, amrex::Real zp, amrex::Real &Exp, amrex::Real &Eyp, amrex::Real &Ezp, amrex::Real &Bxp, amrex::Real &Byp, amrex::Real &Bzp, diff --git a/Source/Particles/PulsarParameters.cpp b/Source/Particles/PulsarParameters.cpp index fd3f661d388..115a97037a7 100644 --- a/Source/Particles/PulsarParameters.cpp +++ b/Source/Particles/PulsarParameters.cpp @@ -15,14 +15,17 @@ namespace PulsarParm AMREX_GPU_DEVICE_MANAGED amrex::Real dR_star; AMREX_GPU_DEVICE_MANAGED int EB_external = 0; AMREX_GPU_DEVICE_MANAGED int E_external_monopole = 0; - AMREX_GPU_DEVICE_MANAGED amrex::Vector center_star(3,0.0); + AMREX_GPU_DEVICE_MANAGED + amrex::GpuArray center_star(3,0.0); AMREX_GPU_DEVICE_MANAGED int verbose = 0; void ReadParameters() { amrex::ParmParse pp("pulsar"); pp.query("pulsarType",pulsar_type); pp.query("omega_star",omega_star); - pp.queryarr("center_star",center_star); + amrex::Vector center_star_v(AMREX_SPACEDIM); + pp.queryarr("center_star",center_star_v); + std::copy(center_star_v.begin(),center_star_v.end(),center_star.begin()); pp.query("R_star",R_star); pp.query("B_star",B_star); pp.query("dR",dR_star); @@ -34,6 +37,7 @@ namespace PulsarParm amrex::Print() << " Pulsar B_star : " << B_star << "\n"; } + AMREX_GPU_HOST_DEVICE AMREX_INLINE void PulsarEBField(amrex::Real xp, amrex::Real yp, amrex::Real zp, amrex::Real &Exp, amrex::Real &Eyp, amrex::Real &Ezp, amrex::Real &Bxp, amrex::Real &Byp, amrex::Real &Bzp, From 9f3907a7dafcd74d9ed17f701c1a4f872aeba9ce Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Wed, 22 Jan 2020 11:12:24 -0800 Subject: [PATCH 019/120] removing EOL whitespace --- Source/Particles/PulsarParameters.H | 2 +- Source/Particles/PulsarParameters.cpp | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Source/Particles/PulsarParameters.H b/Source/Particles/PulsarParameters.H index 61b3dbe63f3..e66650b4cb3 100644 --- a/Source/Particles/PulsarParameters.H +++ b/Source/Particles/PulsarParameters.H @@ -15,7 +15,7 @@ namespace PulsarParm extern AMREX_GPU_DEVICE_MANAGED amrex::Real dR_star; extern AMREX_GPU_DEVICE_MANAGED int EB_external; extern AMREX_GPU_DEVICE_MANAGED int E_external_monopole; - extern AMREX_GPU_DEVICE_MANAGED + extern AMREX_GPU_DEVICE_MANAGED amrex::GpuArray center_star; extern AMREX_GPU_DEVICE_MANAGED int verbose; diff --git a/Source/Particles/PulsarParameters.cpp b/Source/Particles/PulsarParameters.cpp index 115a97037a7..376244cd81a 100644 --- a/Source/Particles/PulsarParameters.cpp +++ b/Source/Particles/PulsarParameters.cpp @@ -15,8 +15,8 @@ namespace PulsarParm AMREX_GPU_DEVICE_MANAGED amrex::Real dR_star; AMREX_GPU_DEVICE_MANAGED int EB_external = 0; AMREX_GPU_DEVICE_MANAGED int E_external_monopole = 0; - AMREX_GPU_DEVICE_MANAGED - amrex::GpuArray center_star(3,0.0); + AMREX_GPU_DEVICE_MANAGED + amrex::GpuArray center_star; AMREX_GPU_DEVICE_MANAGED int verbose = 0; void ReadParameters() { From 71263c6ff818be042429d70e6f242e861c1b6632 Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Thu, 23 Jan 2020 15:37:14 -0800 Subject: [PATCH 020/120] cleaning --- Source/Initialization/PlasmaInjector.cpp | 2 +- Source/Particles/PhysicalParticleContainer.cpp | 18 ------------------ 2 files changed, 1 insertion(+), 19 deletions(-) diff --git a/Source/Initialization/PlasmaInjector.cpp b/Source/Initialization/PlasmaInjector.cpp index 632e425c978..c8ebcadd606 100644 --- a/Source/Initialization/PlasmaInjector.cpp +++ b/Source/Initialization/PlasmaInjector.cpp @@ -551,7 +551,7 @@ bool PlasmaInjector::insideBounds (Real x, Real y, Real z) const noexcept #ifdef PULSAR bool PlasmaInjector::insidePulsarBounds (Real r, Real R_star, Real dR_star) const noexcept { - return (r >= R_star and r <= R_star + dR_star); + return (r <= R_star and r <= R_star - dR_star); } #endif diff --git a/Source/Particles/PhysicalParticleContainer.cpp b/Source/Particles/PhysicalParticleContainer.cpp index ae8491621c7..5035d67187f 100644 --- a/Source/Particles/PhysicalParticleContainer.cpp +++ b/Source/Particles/PhysicalParticleContainer.cpp @@ -552,23 +552,6 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) #ifdef PULSAR amrex::Print() << " in add plasma" << PulsarParm::R_star << "\n"; - // Steps to implement - // 1. inside PulsarBound p.id = -1 if not within R_star+dR_star -- done - // 2. find sigma of the cell the particle belongs to - // 2a. Cell Id of the particle - // 2b. Get x,y,z -> r,theta,phi of the cell. if r >R_star-dR and rthreshold. - // Ninj = sigma*Area/wt - // 2g. We introduce Nc particles every timestep - // Only Ninj are supposed to be injected. - // inject every (ip%(Nc/Ninj)==0) particle - // else p.id = -1 - - #endif // If no part_realbox is provided, initialize particles in the whole domain @@ -628,7 +611,6 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) const MultiFab& Ez_mf = WarpX::GetInstance().getEfield(lev,2); const MultiFab& rho_mf = WarpX::GetInstance().getRho(lev); const Real dt = WarpX::GetInstance().getdt(0); -// if (t > 100*dt) {return;} #endif #ifdef WARPX_DIM_RZ From 4c039860b0844a96c98229ad52fd6d4109f809c3 Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Thu, 23 Jan 2020 17:14:42 -0800 Subject: [PATCH 021/120] adding input parameters to toggle rho gj scaling, ninjection, maxden --- .../pulsar/inputs.corotating.3d.PM | 16 +++------ .../Particles/PhysicalParticleContainer.cpp | 33 +++++++++---------- Source/Particles/PulsarParameters.H | 3 ++ Source/Particles/PulsarParameters.cpp | 9 +++++ 4 files changed, 31 insertions(+), 30 deletions(-) diff --git a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM index 53939bff527..05f5d781201 100644 --- a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM +++ b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM @@ -46,7 +46,7 @@ my_constants.omega = 6245.676 my_constants.c = 299792458. my_constants.B_star = 8.0323e-6 # magnetic field of NS (T) my_constants.dR = 1.4e3 -my_constants.to = -2e-4 +my_constants.to = 2e-4 interpolation.nox = 3 interpolation.noy = 3 interpolation.noz = 3 @@ -70,14 +70,9 @@ plasma_e.charge = -q_e plasma_e.mass = m_e plasma_e.injection_style = "NUniformPerCell" plasma_e.profile = parse_density_function -#plasma_e.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star) * ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<(r_star+dR)) )*dens" plasma_e.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star) * ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=(r_star-dR)) )*dens" plasma_e.num_particles_per_cell_each_dim = 3 3 3 plasma_e.momentum_distribution_type = parse_momentum_function -#plasma_e.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(-( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" -#plasma_e.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*( ( (t=to)*omega ) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" -#plasma_e.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(-omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" -#plasma_e.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" plasma_e.momentum_function_uz(x,y,z) = "0.0" plasma_e.momentum_function_ux(x,y,z) = "0.0" plasma_e.momentum_function_uy(x,y,z) = "0.0" @@ -92,12 +87,6 @@ plasma_p.profile = parse_density_function plasma_p.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star) * ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=(r_star-dR)) )*dens" plasma_p.num_particles_per_cell_each_dim = 3 3 3 plasma_p.momentum_distribution_type = parse_momentum_function -#plasma_p.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(-omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" -#plasma_p.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" -#plasma_p.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*(-( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" -#plasma_p.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*( ( (t=to)*omega ) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" -#plasma_p.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(-omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" -#plasma_p.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" plasma_p.momentum_function_uz(x,y,z) = "0.0" plasma_p.momentum_function_ux(x,y,z) = "0.0" plasma_p.momentum_function_uy(x,y,z) = "0.0" @@ -117,3 +106,6 @@ pulsar.dR = 1.4e3 pulsar.verbose = 0 # [0/1]: turn on verbosity for debugging print statements pulsar.EB_external = 1 # [0/1]: to apply external E and B pulsar.E_external_monopole = 1 # [0/1] +pulsar.max_ndens = 5.54e6 # max ndens == ndens used in initializing density +pulsar.Ninj_fraction = 0.5 # fraction of sigma injected +pulsar.rhoGJ_scale = 1e0 # scaling down of rho_GJ diff --git a/Source/Particles/PhysicalParticleContainer.cpp b/Source/Particles/PhysicalParticleContainer.cpp index 5035d67187f..683c7b239f0 100644 --- a/Source/Particles/PhysicalParticleContainer.cpp +++ b/Source/Particles/PhysicalParticleContainer.cpp @@ -909,19 +909,18 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) const amrex::Real c_phi = std::cos(cc_phi); const amrex::Real s_phi = std::sin(cc_phi); amrex::Real omega = PulsarParm::omega_star; - //if (t < 2.0e-4) { - // omega = PulsarParm::omega_star*t/2.0e-4; - //} + if (t < 2.0e-4) { + omega = PulsarParm::omega_star*t/2.0e-4; + } amrex::Real ratio = PulsarParm::R_star/cc_rad; amrex::Real r3 = ratio*ratio*ratio; amrex::Real Er_cor = PulsarParm::B_star *omega *cc_rad*s_theta*s_theta; - Real Er_ext = omega*PulsarParm::B_star*PulsarParm::R_star - *(1.0-3.0*c_theta*c_theta); - Er_ext += (2.0/3.0)*omega*PulsarParm::B_star*PulsarParm::R_star; - amrex::Real rho_GJ = 2*8.85e-12*PulsarParm::B_star*omega - *PulsarParm::R_star*(1.0-3.0*c_theta*c_theta); + Real Er_ext = omega*PulsarParm::B_star*cc_rad*(1.0-3.0*c_theta*c_theta); + Er_ext += (2.0/3.0)*omega*PulsarParm::B_star*cc_rad; + amrex::Real rho_GJ = 2.*PhysConst::ep0*PulsarParm::B_star*omega* + cc_rad*(1.0-3.0*c_theta*c_theta)*PulsarParm::rhoGJ_scale; int ii = Ex_lo.x + iv[0]; int jj = Ex_lo.y + iv[1]; int kk = Ex_lo.z + iv[2]; @@ -930,13 +929,11 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) Real ez_avg = 0.25*(ex_arr(ii,jj,kk) + ex_arr(ii,jj+1,kk)+ex_arr(ii+1,jj,kk) + ex_arr(ii+1,jj+1,kk)); Real Er_cell = ex_avg*s_theta*c_phi + ey_avg*s_theta*s_phi + ez_avg*c_theta; // analytical surface charge density - Real sigma_inj = PhysConst::ep0*(( Er_ext - Er_cor)); - // hard-coded input parameter -- ndenx = max_dens - Real max_dens = 5.54e6; - // hard-coded fraction of particles injected - amrex::Real fraction = 0.05; + Real sigma_inj = (( Er_ext - Er_cor)); + Real max_dens = PulsarParm::max_ndens; + amrex::Real fraction = PulsarParm::Ninj_fraction; // number of particle pairs injected - Real N_inj = fraction*std::abs(sigma_inj) * dx[0]*dx[0]/(PhysConst::q_e*max_dens*scale_fac); + Real N_inj = fraction*std::abs(sigma_inj) *PhysConst::ep0* dx[0]*dx[0]/(PhysConst::q_e*max_dens*scale_fac); if (t > 0) { if (N_inj >= 1) { if (N_inj < num_ppc) { @@ -955,19 +952,19 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) //if (sigma_inj < 0 and q_pm >0) {p.id()=-1; return;} //if (sigma_inj > 0 and q_pm <0) {p.id()=-1; return;} // if rho is too smal -- we dont inject particles - if (std::abs(rho_GJ) < 1E-25) { - // amrex::Print() << " rho is " << rho_arr(ii,jj,kk) << " rho_GJ " << rho_GJ << " rho gj is zero \n"; + if (std::abs(rho_GJ) < 1E-35) { p.id() = -1; continue; } else { + if (std::abs(rho_arr(ii,jj,kk)) > 0) { Real rel_rho_err = std::abs((rho_arr(ii,jj,kk) - rho_GJ)/rho_GJ); //amrex::Print() << " rho is " << rho_arr(ii,jj,kk) << " rho_GJ " << rho_GJ << " rel err : " << rel_rho_err << "\n"; - //amrex::Print() << " Er_Cell " << Er_cell << " " << " Er_Ext " << Er_ext <<" Er cor " << Er_cor << "\n"; - if ( rel_rho_err < 0.3) { + if ( rel_rho_err < 0.05) { p.id() = -1; continue; } + } } } #endif diff --git a/Source/Particles/PulsarParameters.H b/Source/Particles/PulsarParameters.H index e66650b4cb3..31684ef4a37 100644 --- a/Source/Particles/PulsarParameters.H +++ b/Source/Particles/PulsarParameters.H @@ -17,6 +17,9 @@ namespace PulsarParm extern AMREX_GPU_DEVICE_MANAGED int E_external_monopole; extern AMREX_GPU_DEVICE_MANAGED amrex::GpuArray center_star; + extern AMREX_GPU_DEVICE_MANAGED amrex::Real max_ndens; + extern AMREX_GPU_DEVICE_MANAGED amrex::Real Ninj_fraction; + extern AMREX_GPU_DEVICE_MANAGED amrex::Real rhoGJ_scale; extern AMREX_GPU_DEVICE_MANAGED int verbose; diff --git a/Source/Particles/PulsarParameters.cpp b/Source/Particles/PulsarParameters.cpp index 376244cd81a..1d1102db74d 100644 --- a/Source/Particles/PulsarParameters.cpp +++ b/Source/Particles/PulsarParameters.cpp @@ -18,6 +18,9 @@ namespace PulsarParm AMREX_GPU_DEVICE_MANAGED amrex::GpuArray center_star; AMREX_GPU_DEVICE_MANAGED int verbose = 0; + AMREX_GPU_DEVICE_MANAGED amrex::Real max_ndens; + AMREX_GPU_DEVICE_MANAGED amrex::Real Ninj_fraction; + AMREX_GPU_DEVICE_MANAGED amrex::Real rhoGJ_scale; void ReadParameters() { amrex::ParmParse pp("pulsar"); @@ -35,6 +38,12 @@ namespace PulsarParm amrex::Print() << " Pulsar center: " << center_star[0] << " " << center_star[1] << " " << center_star[2] << "\n"; amrex::Print() << " Pulsar omega: " << omega_star << "\n"; amrex::Print() << " Pulsar B_star : " << B_star << "\n"; + pp.get("max_ndens", max_ndens); + pp.get("Ninj_fraction",Ninj_fraction); + pp.get("rhoGJ_scale",rhoGJ_scale); + amrex::Print() << " pulsar max ndens " << max_ndens << "\n"; + amrex::Print() << " pulsar ninj fraction " << Ninj_fraction << "\n"; + amrex::Print() << " pulsar rhoGJ scaling " << rhoGJ_scale << "\n"; } AMREX_GPU_HOST_DEVICE AMREX_INLINE From 48d1a68e79e745ed0a2b3b6df9484f555ead5332 Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Thu, 23 Jan 2020 17:39:27 -0800 Subject: [PATCH 022/120] removing unwanted insidePulsarBound function --- Source/Initialization/PlasmaInjector.H | 4 ---- Source/Initialization/PlasmaInjector.cpp | 7 ------- 2 files changed, 11 deletions(-) diff --git a/Source/Initialization/PlasmaInjector.H b/Source/Initialization/PlasmaInjector.H index e8d82b5ac3a..ce4d3184242 100644 --- a/Source/Initialization/PlasmaInjector.H +++ b/Source/Initialization/PlasmaInjector.H @@ -46,10 +46,6 @@ public: // bool: whether the point (x, y, z) is inside the plasma region bool insideBounds (amrex::Real x, amrex::Real y, amrex::Real z) const noexcept; -#ifdef PULSAR - bool insidePulsarBounds (amrex::Real r, amrex::Real R_star, - amrex::Real dR_star) const noexcept; -#endif // bool: whether the region defined by lo and hi overlaps with the plasma region bool overlapsWith (const amrex::XDim3& lo, const amrex::XDim3& hi) const noexcept; diff --git a/Source/Initialization/PlasmaInjector.cpp b/Source/Initialization/PlasmaInjector.cpp index c8ebcadd606..e838cfcb4c1 100644 --- a/Source/Initialization/PlasmaInjector.cpp +++ b/Source/Initialization/PlasmaInjector.cpp @@ -548,13 +548,6 @@ bool PlasmaInjector::insideBounds (Real x, Real y, Real z) const noexcept z < zmax and z >= zmin); } -#ifdef PULSAR -bool PlasmaInjector::insidePulsarBounds (Real r, Real R_star, Real dR_star) const noexcept -{ - return (r <= R_star and r <= R_star - dR_star); -} -#endif - bool PlasmaInjector::overlapsWith (const amrex::XDim3& lo, const amrex::XDim3& hi) const noexcept { From 4e0e106de298fb55c4ef8eaccab79ef085b4daf4 Mon Sep 17 00:00:00 2001 From: "Donald E. Willcox" Date: Tue, 21 Jan 2020 15:04:37 -0800 Subject: [PATCH 023/120] Damp electric fields internal to the pulsar when compiling with PULSAR on. --- Source/Evolve/WarpXEvolve.cpp | 44 +++++++++++++++++++++++++++ Source/Particles/PulsarParameters.H | 31 +++++++++++++++++++ Source/Particles/PulsarParameters.cpp | 2 ++ 3 files changed, 77 insertions(+) diff --git a/Source/Evolve/WarpXEvolve.cpp b/Source/Evolve/WarpXEvolve.cpp index ef60380cccc..8b6b92d865b 100644 --- a/Source/Evolve/WarpXEvolve.cpp +++ b/Source/Evolve/WarpXEvolve.cpp @@ -21,6 +21,10 @@ #include #include +#ifdef PULSAR +#include +#endif + using namespace amrex; void @@ -168,6 +172,46 @@ WarpX::Evolve (int numsteps) // B : guard cells are NOT up-to-date } +#ifdef PULSAR + if (PulsarParm::damp_E_internal) { + MultiFab *Ex, *Ey, *Ez; + for (int lev = 0; lev <= finest_level; ++lev) { + Ex = Efield_fp[lev][0].get(); + Ey = Efield_fp[lev][1].get(); + Ez = Efield_fp[lev][2].get(); + + auto geom = Geom(lev).data(); +#ifdef _OPENMP +#pragma omp parallel if (Gpu::notInLaunchRegion()) +#endif + for ( MFIter mfi(*Ex, TilingIfNotGPU()); mfi.isValid(); ++mfi ) + { + const Box& tex = mfi.tilebox(Ex_nodal_flag); + const Box& tey = mfi.tilebox(Ey_nodal_flag); + const Box& tez = mfi.tilebox(Ez_nodal_flag); + + auto const& Exfab = Ex->array(mfi); + auto const& Eyfab = Ey->array(mfi); + auto const& Ezfab = Ez->array(mfi); + + amrex::ParallelFor(tex, tey, tez, + [=] AMREX_GPU_DEVICE (int i, int j, int k) + { + PulsarParm::PulsarDampEField(i, j, k, geom, Exfab); + }, + [=] AMREX_GPU_DEVICE (int i, int j, int k) + { + PulsarParm::PulsarDampEField(i, j, k, geom, Eyfab); + }, + [=] AMREX_GPU_DEVICE (int i, int j, int k) + { + PulsarParm::PulsarDampEField(i, j, k, geom, Ezfab); + }); + } + } + } +#endif + if (cur_time + dt[0] >= stop_time - 1.e-3*dt[0] || step == numsteps_max-1) { // At the end of last step, push p by 0.5*dt to synchronize UpdateAuxilaryData(); diff --git a/Source/Particles/PulsarParameters.H b/Source/Particles/PulsarParameters.H index 31684ef4a37..8a09bfe0d2d 100644 --- a/Source/Particles/PulsarParameters.H +++ b/Source/Particles/PulsarParameters.H @@ -4,6 +4,8 @@ #include #include #include +#include +#include namespace PulsarParm { @@ -20,6 +22,7 @@ namespace PulsarParm extern AMREX_GPU_DEVICE_MANAGED amrex::Real max_ndens; extern AMREX_GPU_DEVICE_MANAGED amrex::Real Ninj_fraction; extern AMREX_GPU_DEVICE_MANAGED amrex::Real rhoGJ_scale; + extern AMREX_GPU_DEVICE_MANAGED int damp_E_internal; extern AMREX_GPU_DEVICE_MANAGED int verbose; @@ -30,6 +33,34 @@ namespace PulsarParm amrex::Real &Bxp, amrex::Real &Byp, amrex::Real &Bzp, amrex::Real time); + AMREX_GPU_HOST_DEVICE AMREX_INLINE + void PulsarDampEField(int i, int j, int k, amrex::GeometryData const& geom, amrex::Array4 const& Efield) + { + const auto domain_box = geom.Domain(); + const auto domain_ilo = amrex::lbound(domain_box); + const auto domain_xlo = geom.ProbLo(); + const auto domain_xhi = geom.ProbHi(); + const auto domain_dx = geom.CellSize(); + + // damp Ex + const amrex::Real x = domain_xlo[0] + (i - domain_ilo.x + 0.5) * domain_dx[0]; + const amrex::Real y = domain_xlo[1] + (j - domain_ilo.y + 0.5) * domain_dx[1]; + const amrex::Real z = domain_xlo[2] + (k - domain_ilo.z + 0.5) * domain_dx[2]; + + const amrex::Real xc = 0.5 * (domain_xlo[0] + domain_xhi[0]); + const amrex::Real yc = 0.5 * (domain_xlo[1] + domain_xhi[1]); + const amrex::Real zc = 0.5 * (domain_xlo[2] + domain_xhi[2]); + + const amrex::Real r = std::sqrt((x-xc)*(x-xc) + (y-yc)*(y-yc) + (z-zc)*(z-zc)); + + if (r < PulsarParm::R_star) { + // Damping function: Fd = 0.5*(tanh(x-0.5*R_star)+1) + // Fd(0) ~ 0 + // Fd(R_star) ~ 1 + const amrex::Real Fd = 0.5 * (std::tanh(r - 0.5 * PulsarParm::R_star) + 1.0); + Efield(i, j, k) = Efield(i, j, k) * Fd; + } + } } #endif diff --git a/Source/Particles/PulsarParameters.cpp b/Source/Particles/PulsarParameters.cpp index 1d1102db74d..fa5762b5bd2 100644 --- a/Source/Particles/PulsarParameters.cpp +++ b/Source/Particles/PulsarParameters.cpp @@ -17,6 +17,7 @@ namespace PulsarParm AMREX_GPU_DEVICE_MANAGED int E_external_monopole = 0; AMREX_GPU_DEVICE_MANAGED amrex::GpuArray center_star; + AMREX_GPU_DEVICE_MANAGED int damp_E_internal = 0; AMREX_GPU_DEVICE_MANAGED int verbose = 0; AMREX_GPU_DEVICE_MANAGED amrex::Real max_ndens; AMREX_GPU_DEVICE_MANAGED amrex::Real Ninj_fraction; @@ -35,6 +36,7 @@ namespace PulsarParm pp.query("verbose",verbose); pp.query("EB_external",EB_external); pp.query("E_external_monopole",E_external_monopole); + pp.query("damp_E_internal",damp_E_internal); amrex::Print() << " Pulsar center: " << center_star[0] << " " << center_star[1] << " " << center_star[2] << "\n"; amrex::Print() << " Pulsar omega: " << omega_star << "\n"; amrex::Print() << " Pulsar B_star : " << B_star << "\n"; From 7c033b349d334e836cabafdc72f468c24fa8e71f Mon Sep 17 00:00:00 2001 From: "Donald E. Willcox" Date: Tue, 21 Jan 2020 15:05:32 -0800 Subject: [PATCH 024/120] Turn on inputs parameter to damp internal E-field for the pulsar setup. --- Examples/Physics_applications/pulsar/inputs.corotating.3d.PM | 1 + 1 file changed, 1 insertion(+) diff --git a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM index 05f5d781201..1f5399db27d 100644 --- a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM +++ b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM @@ -109,3 +109,4 @@ pulsar.E_external_monopole = 1 # [0/1] pulsar.max_ndens = 5.54e6 # max ndens == ndens used in initializing density pulsar.Ninj_fraction = 0.5 # fraction of sigma injected pulsar.rhoGJ_scale = 1e0 # scaling down of rho_GJ +pulsar.damp_E_internal = 1 # Damp internal electric field From 274ad5738a97ffceb5110c492082357724040061 Mon Sep 17 00:00:00 2001 From: "Donald E. Willcox" Date: Tue, 21 Jan 2020 15:56:56 -0800 Subject: [PATCH 025/120] Separate out cartesian ijk -> spherical radius into a utility function so it can be used elsewhere. --- Source/Particles/PulsarParameters.H | 52 +++++++++++++++++------------ 1 file changed, 31 insertions(+), 21 deletions(-) diff --git a/Source/Particles/PulsarParameters.H b/Source/Particles/PulsarParameters.H index 8a09bfe0d2d..80ccec65a03 100644 --- a/Source/Particles/PulsarParameters.H +++ b/Source/Particles/PulsarParameters.H @@ -33,34 +33,44 @@ namespace PulsarParm amrex::Real &Bxp, amrex::Real &Byp, amrex::Real &Bzp, amrex::Real time); - AMREX_GPU_HOST_DEVICE AMREX_INLINE - void PulsarDampEField(int i, int j, int k, amrex::GeometryData const& geom, amrex::Array4 const& Efield) + namespace Spherical { - const auto domain_box = geom.Domain(); - const auto domain_ilo = amrex::lbound(domain_box); - const auto domain_xlo = geom.ProbLo(); - const auto domain_xhi = geom.ProbHi(); - const auto domain_dx = geom.CellSize(); + AMREX_GPU_HOST_DEVICE AMREX_INLINE + amrex::Real r(int i, int j, int k, amrex::GeometryData const& geom) + { + const auto domain_box = geom.Domain(); + const auto domain_ilo = amrex::lbound(domain_box); + const auto domain_xlo = geom.ProbLo(); + const auto domain_xhi = geom.ProbHi(); + const auto domain_dx = geom.CellSize(); - // damp Ex - const amrex::Real x = domain_xlo[0] + (i - domain_ilo.x + 0.5) * domain_dx[0]; - const amrex::Real y = domain_xlo[1] + (j - domain_ilo.y + 0.5) * domain_dx[1]; - const amrex::Real z = domain_xlo[2] + (k - domain_ilo.z + 0.5) * domain_dx[2]; + const amrex::Real x = domain_xlo[0] + (i - domain_ilo.x + 0.5) * domain_dx[0]; + const amrex::Real y = domain_xlo[1] + (j - domain_ilo.y + 0.5) * domain_dx[1]; + const amrex::Real z = domain_xlo[2] + (k - domain_ilo.z + 0.5) * domain_dx[2]; - const amrex::Real xc = 0.5 * (domain_xlo[0] + domain_xhi[0]); - const amrex::Real yc = 0.5 * (domain_xlo[1] + domain_xhi[1]); - const amrex::Real zc = 0.5 * (domain_xlo[2] + domain_xhi[2]); + const amrex::Real xc = 0.5 * (domain_xlo[0] + domain_xhi[0]); + const amrex::Real yc = 0.5 * (domain_xlo[1] + domain_xhi[1]); + const amrex::Real zc = 0.5 * (domain_xlo[2] + domain_xhi[2]); - const amrex::Real r = std::sqrt((x-xc)*(x-xc) + (y-yc)*(y-yc) + (z-zc)*(z-zc)); + const amrex::Real r = std::sqrt((x-xc)*(x-xc) + (y-yc)*(y-yc) + (z-zc)*(z-zc)); - if (r < PulsarParm::R_star) { - // Damping function: Fd = 0.5*(tanh(x-0.5*R_star)+1) - // Fd(0) ~ 0 - // Fd(R_star) ~ 1 - const amrex::Real Fd = 0.5 * (std::tanh(r - 0.5 * PulsarParm::R_star) + 1.0); - Efield(i, j, k) = Efield(i, j, k) * Fd; + return r; } } + + AMREX_GPU_HOST_DEVICE AMREX_INLINE + void PulsarDampEField(int i, int j, int k, amrex::GeometryData const& geom, amrex::Array4 const& Efield) + { + const amrex::Real r = Spherical::r(i, j, k, geom); + + if (r < PulsarParm::R_star) { + // Damping function: Fd = 0.5*(tanh(r-0.5*R_star)+1) + // Fd(0) ~ 0 + // Fd(R_star) ~ 1 + const amrex::Real Fd = 0.5 * (std::tanh(r - 0.5 * PulsarParm::R_star) + 1.0); + Efield(i, j, k) = Efield(i, j, k) * Fd; + } + } } #endif From dcd1d8d91fedb87bcc2deed69bb59737828e3f3d Mon Sep 17 00:00:00 2001 From: "Donald E. Willcox" Date: Tue, 21 Jan 2020 18:51:51 -0800 Subject: [PATCH 026/120] Rename damping function, damp in domain [0, R_star-dR_star]. Normalize argument to tanh in damping formula. --- Source/Evolve/WarpXEvolve.cpp | 6 +++--- Source/Particles/PulsarParameters.H | 11 ++++++----- 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/Source/Evolve/WarpXEvolve.cpp b/Source/Evolve/WarpXEvolve.cpp index 8b6b92d865b..4e394ca3a03 100644 --- a/Source/Evolve/WarpXEvolve.cpp +++ b/Source/Evolve/WarpXEvolve.cpp @@ -197,15 +197,15 @@ WarpX::Evolve (int numsteps) amrex::ParallelFor(tex, tey, tez, [=] AMREX_GPU_DEVICE (int i, int j, int k) { - PulsarParm::PulsarDampEField(i, j, k, geom, Exfab); + PulsarParm::DampEField(i, j, k, geom, Exfab); }, [=] AMREX_GPU_DEVICE (int i, int j, int k) { - PulsarParm::PulsarDampEField(i, j, k, geom, Eyfab); + PulsarParm::DampEField(i, j, k, geom, Eyfab); }, [=] AMREX_GPU_DEVICE (int i, int j, int k) { - PulsarParm::PulsarDampEField(i, j, k, geom, Ezfab); + PulsarParm::DampEField(i, j, k, geom, Ezfab); }); } } diff --git a/Source/Particles/PulsarParameters.H b/Source/Particles/PulsarParameters.H index 80ccec65a03..6c65274e6de 100644 --- a/Source/Particles/PulsarParameters.H +++ b/Source/Particles/PulsarParameters.H @@ -59,15 +59,16 @@ namespace PulsarParm } AMREX_GPU_HOST_DEVICE AMREX_INLINE - void PulsarDampEField(int i, int j, int k, amrex::GeometryData const& geom, amrex::Array4 const& Efield) + void DampEField(int i, int j, int k, amrex::GeometryData const& geom, amrex::Array4 const& Efield) { const amrex::Real r = Spherical::r(i, j, k, geom); + const amrex::Real R_inner = PulsarParm::R_star - PulsarParm::dR_star; - if (r < PulsarParm::R_star) { - // Damping function: Fd = 0.5*(tanh(r-0.5*R_star)+1) + if (r < R_inner) { + // Damping function: Fd = 0.5*(tanh(7 * (r/R_inner-0.5))+1) // Fd(0) ~ 0 - // Fd(R_star) ~ 1 - const amrex::Real Fd = 0.5 * (std::tanh(r - 0.5 * PulsarParm::R_star) + 1.0); + // Fd(R_inner) ~ 1 + const amrex::Real Fd = 0.5*(std::tanh(7 * (r/R_inner-0.5))+1); Efield(i, j, k) = Efield(i, j, k) * Fd; } } From 2a52a9ff0199141e4891eb56a2dadb0f8dea2185 Mon Sep 17 00:00:00 2001 From: "Donald E. Willcox" Date: Wed, 22 Jan 2020 21:05:37 -0800 Subject: [PATCH 027/120] Add PulsarParm::Omega(t) function that returns omega(t) depending on ramp_omega_time input parameter. If ramp_omega_time < 0, PulsarParm::Omega(t) = omega_star. --- Source/Particles/PhysicalParticleContainer.cpp | 11 ++++++----- Source/Particles/PulsarParameters.H | 12 ++++++++++++ Source/Particles/PulsarParameters.cpp | 18 +++++++++--------- 3 files changed, 27 insertions(+), 14 deletions(-) diff --git a/Source/Particles/PhysicalParticleContainer.cpp b/Source/Particles/PhysicalParticleContainer.cpp index 683c7b239f0..af3eb424fcb 100644 --- a/Source/Particles/PhysicalParticleContainer.cpp +++ b/Source/Particles/PhysicalParticleContainer.cpp @@ -906,12 +906,13 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) amrex::Real cc_phi = std::atan2((cc_y-yc),(cc_x-xc)); const amrex::Real c_theta = std::cos(cc_theta); const amrex::Real s_theta = std::sin(cc_theta); - const amrex::Real c_phi = std::cos(cc_phi); - const amrex::Real s_phi = std::sin(cc_phi); - amrex::Real omega = PulsarParm::omega_star; - if (t < 2.0e-4) { - omega = PulsarParm::omega_star*t/2.0e-4; + amrex::Real c_phi = 0.; + amrex::Real s_phi = 0.; + if (r_cl > 0) { + c_phi = (cc_x-xc)/r_cl; + s_phi = (cc_y-yc)/r_cl; } + amrex::Real omega = PulsarParm::Omega(t); amrex::Real ratio = PulsarParm::R_star/cc_rad; amrex::Real r3 = ratio*ratio*ratio; amrex::Real Er_cor = PulsarParm::B_star diff --git a/Source/Particles/PulsarParameters.H b/Source/Particles/PulsarParameters.H index 6c65274e6de..6fa6fb12fb8 100644 --- a/Source/Particles/PulsarParameters.H +++ b/Source/Particles/PulsarParameters.H @@ -12,6 +12,7 @@ namespace PulsarParm extern std::string pulsar_type; extern AMREX_GPU_DEVICE_MANAGED amrex::Real omega_star; + extern AMREX_GPU_DEVICE_MANAGED amrex::Real ramp_omega_time; extern AMREX_GPU_DEVICE_MANAGED amrex::Real B_star; extern AMREX_GPU_DEVICE_MANAGED amrex::Real R_star; extern AMREX_GPU_DEVICE_MANAGED amrex::Real dR_star; @@ -58,6 +59,17 @@ namespace PulsarParm } } + AMREX_GPU_HOST_DEVICE AMREX_INLINE + amrex::Real Omega(const amrex::Real time) + { + amrex::Real omega = omega_star; + if (ramp_omega_time > 0.0 && time < ramp_omega_time) { + omega = omega_star * time / ramp_omega_time; + } + + return omega; + } + AMREX_GPU_HOST_DEVICE AMREX_INLINE void DampEField(int i, int j, int k, amrex::GeometryData const& geom, amrex::Array4 const& Efield) { diff --git a/Source/Particles/PulsarParameters.cpp b/Source/Particles/PulsarParameters.cpp index fa5762b5bd2..a5693933bb3 100644 --- a/Source/Particles/PulsarParameters.cpp +++ b/Source/Particles/PulsarParameters.cpp @@ -10,6 +10,7 @@ namespace PulsarParm std::string pulsar_type; AMREX_GPU_DEVICE_MANAGED amrex::Real omega_star; + AMREX_GPU_DEVICE_MANAGED amrex::Real ramp_omega_time = -1.0; AMREX_GPU_DEVICE_MANAGED amrex::Real B_star; AMREX_GPU_DEVICE_MANAGED amrex::Real R_star; AMREX_GPU_DEVICE_MANAGED amrex::Real dR_star; @@ -37,6 +38,7 @@ namespace PulsarParm pp.query("EB_external",EB_external); pp.query("E_external_monopole",E_external_monopole); pp.query("damp_E_internal",damp_E_internal); + pp.query("ramp_omega_time", ramp_omega_time); amrex::Print() << " Pulsar center: " << center_star[0] << " " << center_star[1] << " " << center_star[2] << "\n"; amrex::Print() << " Pulsar omega: " << omega_star << "\n"; amrex::Print() << " Pulsar B_star : " << B_star << "\n"; @@ -67,23 +69,21 @@ namespace PulsarParm const amrex::Real s_theta = std::sin(theta); const amrex::Real c_phi = std::cos(phi); const amrex::Real s_phi = std::sin(phi); - amrex::Real omega = omega_star; - // ramping up omega - if (time < 2.0e-4) { - omega = omega_star*time/2.0e-4; - } + amrex::Real omega = PulsarParm::Omega(time); + + // Inside star :: uniform B a,d E = - (omega X r) X B if (r Date: Thu, 23 Jan 2020 16:42:18 -0800 Subject: [PATCH 028/120] Add comments to distinguish different kinds of momentum injections. Add input parameter for the timescale for ramping up omega. --- .../pulsar/inputs.corotating.3d.PM | 47 +++++++++++++++++-- 1 file changed, 43 insertions(+), 4 deletions(-) diff --git a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM index 1f5399db27d..f358195efeb 100644 --- a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM +++ b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM @@ -73,9 +73,27 @@ plasma_e.profile = parse_density_function plasma_e.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star) * ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=(r_star-dR)) )*dens" plasma_e.num_particles_per_cell_each_dim = 3 3 3 plasma_e.momentum_distribution_type = parse_momentum_function + +## Inject pairs rotating at omega(t) x r velocity +plasma_e.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*(-( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" +plasma_e.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*( ( (t=to)*omega ) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" + +## Inject pairs rotating at omega x r velocity +#plasma_e.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(-omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" +#plasma_e.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" + +## Inject stationary pairs +#plasma_e.momentum_function_ux(x,y,z) = "0.0" +#plasma_e.momentum_function_uy(x,y,z) = "0.0" + +## uz is always 0 for the injection methods above plasma_e.momentum_function_uz(x,y,z) = "0.0" -plasma_e.momentum_function_ux(x,y,z) = "0.0" -plasma_e.momentum_function_uy(x,y,z) = "0.0" + +#plasma_e.momentum_distribution_type = "constant" +#plasma_e.ux = 0.0 +#plasma_e.uy = 0.0 +#plasma_e.uz = 0.0 + plasma_e.do_continuous_injection = 0 plasma_e.density_min = 1E0 @@ -87,9 +105,27 @@ plasma_p.profile = parse_density_function plasma_p.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star) * ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=(r_star-dR)) )*dens" plasma_p.num_particles_per_cell_each_dim = 3 3 3 plasma_p.momentum_distribution_type = parse_momentum_function + +## Inject pairs rotating at omega(t) x r velocity +plasma_p.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*(-( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" +plasma_p.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*( ( (t=to)*omega ) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" + +## Inject pairs rotating at omega x r velocity +#plasma_p.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(-omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" +#plasma_p.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" + +## Inject stationary pairs +#plasma_p.momentum_function_ux(x,y,z) = "0.0" +#plasma_p.momentum_function_uy(x,y,z) = "0.0" + +## uz is always 0 for the injection methods above plasma_p.momentum_function_uz(x,y,z) = "0.0" -plasma_p.momentum_function_ux(x,y,z) = "0.0" -plasma_p.momentum_function_uy(x,y,z) = "0.0" + +#plasma_p.momentum_distribution_type = "constant" +#plasma_p.ux = 0.0 +#plasma_p.uy = 0.0 +#plasma_p.uz = 0.0 + plasma_p.do_continuous_injection = 0 plasma_p.density_min = 1E0 @@ -99,6 +135,9 @@ plasma_p.density_min = 1E0 ################################# pulsar.pulsarType = "dead" # [dead/active]: sets particle injection type pulsar.omega_star = 6245.676 # angular velocity of NS (rad/s) +pulsar.ramp_omega_time = 2e-4 # time over which to ramp up NS angular velocity (s) + # if ramp_omega_time < 0, omega = omega_star for any t + # consistency requires ramp_omega_time = my_constants.to pulsar.center_star = 90000 90000 90000 pulsar.R_star = 12.e3 # radius of NS (m) pulsar.B_star = 8.0323e-6 # magnetic field of NS (T) From f92237ee25da88ee842ac3f8d08d02a197903b96 Mon Sep 17 00:00:00 2001 From: "Donald E. Willcox" Date: Thu, 23 Jan 2020 16:54:46 -0800 Subject: [PATCH 029/120] Change form of damping function to tanh(damping_scale * (r/R_star-1)) + 1 so the damping factor at r=R_star is 1.0. Add pulsar.damping_scale as an input parameter defaulted to a reasonable value of 10. --- Source/Particles/PulsarParameters.H | 12 +++++++----- Source/Particles/PulsarParameters.cpp | 4 +++- 2 files changed, 10 insertions(+), 6 deletions(-) diff --git a/Source/Particles/PulsarParameters.H b/Source/Particles/PulsarParameters.H index 6fa6fb12fb8..de591988a9f 100644 --- a/Source/Particles/PulsarParameters.H +++ b/Source/Particles/PulsarParameters.H @@ -16,6 +16,7 @@ namespace PulsarParm extern AMREX_GPU_DEVICE_MANAGED amrex::Real B_star; extern AMREX_GPU_DEVICE_MANAGED amrex::Real R_star; extern AMREX_GPU_DEVICE_MANAGED amrex::Real dR_star; + extern AMREX_GPU_DEVICE_MANAGED amrex::Real damping_scale; extern AMREX_GPU_DEVICE_MANAGED int EB_external; extern AMREX_GPU_DEVICE_MANAGED int E_external_monopole; extern AMREX_GPU_DEVICE_MANAGED @@ -74,13 +75,14 @@ namespace PulsarParm void DampEField(int i, int j, int k, amrex::GeometryData const& geom, amrex::Array4 const& Efield) { const amrex::Real r = Spherical::r(i, j, k, geom); - const amrex::Real R_inner = PulsarParm::R_star - PulsarParm::dR_star; - if (r < R_inner) { - // Damping function: Fd = 0.5*(tanh(7 * (r/R_inner-0.5))+1) + if (r < R_star) { + // Damping function: Fd = tanh(damping_scale * (r / R_star - 1)) + 1 + // for damping_scale >= 10 or so: // Fd(0) ~ 0 - // Fd(R_inner) ~ 1 - const amrex::Real Fd = 0.5*(std::tanh(7 * (r/R_inner-0.5))+1); + // Fd(R_star) ~ 1 + + const amrex::Real Fd = std::tanh(damping_scale * (r / R_star - 1)) + 1; Efield(i, j, k) = Efield(i, j, k) * Fd; } } diff --git a/Source/Particles/PulsarParameters.cpp b/Source/Particles/PulsarParameters.cpp index a5693933bb3..ccefe5492a1 100644 --- a/Source/Particles/PulsarParameters.cpp +++ b/Source/Particles/PulsarParameters.cpp @@ -14,6 +14,7 @@ namespace PulsarParm AMREX_GPU_DEVICE_MANAGED amrex::Real B_star; AMREX_GPU_DEVICE_MANAGED amrex::Real R_star; AMREX_GPU_DEVICE_MANAGED amrex::Real dR_star; + AMREX_GPU_DEVICE_MANAGED amrex::Real damping_scale = 10.0; AMREX_GPU_DEVICE_MANAGED int EB_external = 0; AMREX_GPU_DEVICE_MANAGED int E_external_monopole = 0; AMREX_GPU_DEVICE_MANAGED @@ -38,7 +39,8 @@ namespace PulsarParm pp.query("EB_external",EB_external); pp.query("E_external_monopole",E_external_monopole); pp.query("damp_E_internal",damp_E_internal); - pp.query("ramp_omega_time", ramp_omega_time); + pp.query("damping_scale",damping_scale); + pp.query("ramp_omega_time",ramp_omega_time); amrex::Print() << " Pulsar center: " << center_star[0] << " " << center_star[1] << " " << center_star[2] << "\n"; amrex::Print() << " Pulsar omega: " << omega_star << "\n"; amrex::Print() << " Pulsar B_star : " << B_star << "\n"; From bb6a12d5ebeabffb8e2b98580ce4b40161667eb6 Mon Sep 17 00:00:00 2001 From: "Donald E. Willcox" Date: Thu, 23 Jan 2020 16:56:02 -0800 Subject: [PATCH 030/120] Add scale factor for damping internal E-field to the inputs file. --- Examples/Physics_applications/pulsar/inputs.corotating.3d.PM | 1 + 1 file changed, 1 insertion(+) diff --git a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM index f358195efeb..8e84c0ade04 100644 --- a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM +++ b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM @@ -149,3 +149,4 @@ pulsar.max_ndens = 5.54e6 # max ndens == ndens used in initializing pulsar.Ninj_fraction = 0.5 # fraction of sigma injected pulsar.rhoGJ_scale = 1e0 # scaling down of rho_GJ pulsar.damp_E_internal = 1 # Damp internal electric field +pulsar.damping_scale = 10.0 # Damping scale factor for internal electric field From bf9cc1067aac7ea9fbff4eb71681c6a64868a7fb Mon Sep 17 00:00:00 2001 From: "Donald E. Willcox" Date: Thu, 23 Jan 2020 17:01:04 -0800 Subject: [PATCH 031/120] Add a python script for making plots and a gif from a set of plotfiles. --- .../Physics_applications/pulsar/pulsar_vis.py | 54 +++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 Examples/Physics_applications/pulsar/pulsar_vis.py diff --git a/Examples/Physics_applications/pulsar/pulsar_vis.py b/Examples/Physics_applications/pulsar/pulsar_vis.py new file mode 100644 index 00000000000..3694a1f91e5 --- /dev/null +++ b/Examples/Physics_applications/pulsar/pulsar_vis.py @@ -0,0 +1,54 @@ +import yt +import os +import glob +import argparse + +parser = argparse.ArgumentParser() +parser.add_argument("-f", "--plotfile", type=str, help="Path to single input plotfile to visualize.") +parser.add_argument("-d", "--dir", type=str, help="Path to input plotfile directory to visualize.") + +args = parser.parse_args() + +def visualize(plt, annotate_particles=True): + ds = yt.load(plt) + sl = yt.SlicePlot(ds, 0, 'Ez', aspect=1) # Create a sliceplot object + if annotate_particles: + sl.annotate_particles(width=(2.e3, 'm'),ptype="plasma_p",col='b',p_size=5.0) + sl.annotate_particles(width=(2.e3, 'm'),ptype="plasma_e",col='r',p_size=5.0) + sl.annotate_streamlines("Ey", "Ez", plot_args={"color": "black"}) + sl.annotate_grids() # Show grids + sl.annotate_sphere([90000.0, 90000.0, 90000.0], radius=12000.0, + circle_args={'color':'white', 'linewidth':2}) + out_name = os.path.join(os.path.dirname(plt), "pulsar_{}.png".format(os.path.basename(plt))) + sl.save(out_name) + +if __name__ == "__main__": + yt.funcs.mylog.setLevel(50) + if args.dir: + failed = [] + plotfiles = glob.glob(os.path.join(args.dir, "plt" + "[0-9]"*5)) + for pf in plotfiles: + try: + visualize(pf) + except: + # plotfile 0 may not have particles, so turn off annotations if we first failed + try: + visualize(pf, annotate_particles=False) + except: + failed.append(pf) + pass + + if len(failed) > 0: + print("Visualization failed for the following plotfiles:") + for fp in failed: + print(fp) + else: + print("No plots failed, creating a gif ...") + input_files = os.path.join(args.dir, "*.png") + output_gif = os.path.join(args.dir, "pulsar.gif") + os.system("convert -delay 20 -loop 0 {} {}".format(input_files, output_gif)) + + elif args.plotfile: + visualize(args.plotfile) + else: + print("Supply either -f or -d options for visualization. Use the -h option to see help.") From 64af47bcc5d0d6b7c13cd691043fb151008e179d Mon Sep 17 00:00:00 2001 From: "Donald E. Willcox" Date: Thu, 23 Jan 2020 18:09:57 -0800 Subject: [PATCH 032/120] Remove PulsarEBField from PulsarParameters.cpp after a rebase mistake. --- Source/Particles/PulsarParameters.cpp | 66 --------------------------- 1 file changed, 66 deletions(-) diff --git a/Source/Particles/PulsarParameters.cpp b/Source/Particles/PulsarParameters.cpp index ccefe5492a1..d0807b3e54c 100644 --- a/Source/Particles/PulsarParameters.cpp +++ b/Source/Particles/PulsarParameters.cpp @@ -52,70 +52,4 @@ namespace PulsarParm amrex::Print() << " pulsar rhoGJ scaling " << rhoGJ_scale << "\n"; } - AMREX_GPU_HOST_DEVICE AMREX_INLINE - void PulsarEBField(amrex::Real xp, amrex::Real yp, amrex::Real zp, - amrex::Real &Exp, amrex::Real &Eyp, amrex::Real &Ezp, - amrex::Real &Bxp, amrex::Real &Byp, amrex::Real &Bzp, - amrex::Real time) { - // spherical r, theta, phi - const amrex::Real xc = center_star[0]; - const amrex::Real yc = center_star[1]; - const amrex::Real zc = center_star[2]; - const amrex::Real r = std::sqrt( (xp-xc)*(xp-xc) + (yp-yc)*(yp-yc) + (zp-zc)*(zp-zc) ); - const amrex::Real phi = std::atan2((yp-yc),(xp-xc)); - amrex::Real theta = 0.0; - if (r > 0) { - theta = std::acos((zp-zc)/r); - } - const amrex::Real c_theta = std::cos(theta); - const amrex::Real s_theta = std::sin(theta); - const amrex::Real c_phi = std::cos(phi); - const amrex::Real s_phi = std::sin(phi); - - amrex::Real omega = PulsarParm::Omega(time); - - // Inside star :: uniform B a,d E = - (omega X r) X B - if (r= R_star ) { - amrex::Real r_ratio = R_star/r; - amrex::Real r3 = r_ratio*r_ratio*r_ratio; - // Taking derivative of phi given in eq 30 of Michel and Li - amrex::Real Er = B_star*omega*R_star*r_ratio*r3*(1.0-3.0*c_theta*c_theta); - if (E_external_monopole == 1) { - Er += (2.0/3.0)*omega*B_star*R_star*r_ratio*r_ratio; - } - amrex::Real Etheta = (-1.0)*B_star*omega*R_star*r_ratio*r3*(2.0*s_theta*c_theta); - - Exp = Er*s_theta*c_phi + Etheta*c_theta*c_phi; - Eyp = Er*s_theta*s_phi + Etheta*c_theta*s_phi; - Ezp = Er*c_theta - Etheta*s_theta; - - amrex::Real Br = 2.0*B_star*r3*c_theta; - amrex::Real Btheta = B_star*r3*s_theta; - - Bxp = Br*s_theta*c_phi + Btheta*c_theta*c_phi; - Byp = Br*s_theta*s_phi + Btheta*c_theta*s_phi; - Bzp = Br*c_theta - Btheta*s_theta; - } - } - } From 0e10b5f0e30007fcdaad9c337161cd75ba855210 Mon Sep 17 00:00:00 2001 From: "Donald E. Willcox" Date: Thu, 23 Jan 2020 18:11:56 -0800 Subject: [PATCH 033/120] Default the momentum initialization to 0. --- .../pulsar/inputs.corotating.3d.PM | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM index 8e84c0ade04..a5c8cc525e8 100644 --- a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM +++ b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM @@ -75,16 +75,16 @@ plasma_e.num_particles_per_cell_each_dim = 3 3 3 plasma_e.momentum_distribution_type = parse_momentum_function ## Inject pairs rotating at omega(t) x r velocity -plasma_e.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*(-( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" -plasma_e.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*( ( (t=to)*omega ) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" +#plasma_e.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*(-( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" +#plasma_e.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*( ( (t=to)*omega ) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" ## Inject pairs rotating at omega x r velocity #plasma_e.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(-omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" #plasma_e.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" ## Inject stationary pairs -#plasma_e.momentum_function_ux(x,y,z) = "0.0" -#plasma_e.momentum_function_uy(x,y,z) = "0.0" +plasma_e.momentum_function_ux(x,y,z) = "0.0" +plasma_e.momentum_function_uy(x,y,z) = "0.0" ## uz is always 0 for the injection methods above plasma_e.momentum_function_uz(x,y,z) = "0.0" @@ -107,16 +107,16 @@ plasma_p.num_particles_per_cell_each_dim = 3 3 3 plasma_p.momentum_distribution_type = parse_momentum_function ## Inject pairs rotating at omega(t) x r velocity -plasma_p.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*(-( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" -plasma_p.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*( ( (t=to)*omega ) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" +#plasma_p.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*(-( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" +#plasma_p.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)*( ( (t=to)*omega ) *(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-( ( (t=to)*omega )*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" ## Inject pairs rotating at omega x r velocity #plasma_p.momentum_function_ux(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(-omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (y-yc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" #plasma_p.momentum_function_uy(x,y,z) = "( (( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star)*(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/((1.0-(omega*(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5))/c)^2)^(0.5)) * (x-xc)/(((x-xc)*(x-xc) + (y-yc)*(y-yc))^(0.5)))" ## Inject stationary pairs -#plasma_p.momentum_function_ux(x,y,z) = "0.0" -#plasma_p.momentum_function_uy(x,y,z) = "0.0" +plasma_p.momentum_function_ux(x,y,z) = "0.0" +plasma_p.momentum_function_uy(x,y,z) = "0.0" ## uz is always 0 for the injection methods above plasma_p.momentum_function_uz(x,y,z) = "0.0" From e1e0fffbefba07616d318f706b70e94350777968 Mon Sep 17 00:00:00 2001 From: "Donald E. Willcox" Date: Thu, 23 Jan 2020 18:16:35 -0800 Subject: [PATCH 034/120] Swap tabs for spaces. --- Source/Particles/PhysicalParticleContainer.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Source/Particles/PhysicalParticleContainer.cpp b/Source/Particles/PhysicalParticleContainer.cpp index af3eb424fcb..b5d91662dc1 100644 --- a/Source/Particles/PhysicalParticleContainer.cpp +++ b/Source/Particles/PhysicalParticleContainer.cpp @@ -789,9 +789,9 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) int loc_ionization_initial_level = ionization_initial_level; #ifdef PULSAR // Fab - const int Ex_nghost = Ex_mf.nGrow(); - const int Ey_nghost = Ey_mf.nGrow(); - const int Ez_nghost = Ez_mf.nGrow(); + const int Ex_nghost = Ex_mf.nGrow(); + const int Ey_nghost = Ey_mf.nGrow(); + const int Ez_nghost = Ez_mf.nGrow(); const FArrayBox& Ex_fab = Ex_mf[mfi]; const FArrayBox& Ey_fab = Ey_mf[mfi]; const FArrayBox& Ez_fab = Ez_mf[mfi]; From ff96a08696f820344313d212b9640091426377ec Mon Sep 17 00:00:00 2001 From: "Donald E. Willcox" Date: Thu, 23 Jan 2020 18:18:39 -0800 Subject: [PATCH 035/120] Ran the style commands suggested by Travis CI to remove trailing whitespace. --- Source/Evolve/WarpXEvolve.cpp | 2 +- Source/Initialization/InjectorPosition.H | 2 +- Source/Particles/MultiParticleContainer.cpp | 8 ++++---- Source/Particles/PhysicalParticleContainer.cpp | 16 ++++++++-------- 4 files changed, 14 insertions(+), 14 deletions(-) diff --git a/Source/Evolve/WarpXEvolve.cpp b/Source/Evolve/WarpXEvolve.cpp index 4e394ca3a03..5a835b59c5d 100644 --- a/Source/Evolve/WarpXEvolve.cpp +++ b/Source/Evolve/WarpXEvolve.cpp @@ -255,7 +255,7 @@ WarpX::Evolve (int numsteps) else { amrex::Print() << " rho is computed \n"; } - mypc->PulsarParticleRemoval(); + mypc->PulsarParticleRemoval(); mypc->PulsarParticleInjection(); #endif diff --git a/Source/Initialization/InjectorPosition.H b/Source/Initialization/InjectorPosition.H index b18d5124bcb..502f0311567 100644 --- a/Source/Initialization/InjectorPosition.H +++ b/Source/Initialization/InjectorPosition.H @@ -142,7 +142,7 @@ struct InjectorPosition // return (r>=R_star and r<=(R_star+dR_star)); return (r<=R_star and r>=(R_star-dR_star)); } -#endif +#endif // bool: whether the region defined by lo and hi overaps with the plasma region AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE diff --git a/Source/Particles/MultiParticleContainer.cpp b/Source/Particles/MultiParticleContainer.cpp index f75a759e9d8..926157d3804 100644 --- a/Source/Particles/MultiParticleContainer.cpp +++ b/Source/Particles/MultiParticleContainer.cpp @@ -1481,20 +1481,20 @@ void MultiParticleContainer::CheckQEDProductSpecies() #endif #ifdef PULSAR -void +void MultiParticleContainer::PulsarParticleInjection() { amrex::Print() << " pulsar injection on! \n"; for (auto& pc : allcontainers) { - pc->PulsarParticleInjection(); + pc->PulsarParticleInjection(); } } -void +void MultiParticleContainer::PulsarParticleRemoval() { amrex::Print() << " pulsar particle removal on! \n"; for (auto& pc : allcontainers) { - pc->PulsarParticleRemoval(); + pc->PulsarParticleRemoval(); } } diff --git a/Source/Particles/PhysicalParticleContainer.cpp b/Source/Particles/PhysicalParticleContainer.cpp index b5d91662dc1..201ff9447a3 100644 --- a/Source/Particles/PhysicalParticleContainer.cpp +++ b/Source/Particles/PhysicalParticleContainer.cpp @@ -803,14 +803,14 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) amrex::Array4 const& ey_arr = Ey_fab.array(); amrex::Array4 const& ez_arr = Ez_fab.array(); amrex::Array4 const& rho_arr = rho_fab.array(); - const Real q_pm = this->charge; + const Real q_pm = this->charge; //amrex::Print() << " box " << x_box << "\n"; //FArrayBox Ey_fab = Ey_mf[mfi]; //Box Ey_box = Ey_fab.validbox(); //FArrayBox Ez_fab = Ez_mf[mfi]; //Box Ez_box = Ez_fab.validbox(); - //amrex::Print() << " Ey box " << Ey_box << "\n"; - //amrex::Print() << " Ez box " << Ez_box << "\n"; + //amrex::Print() << " Ey box " << Ey_box << "\n"; + //amrex::Print() << " Ez box " << Ez_box << "\n"; #endif // Loop over all new particles and inject them (creates too many @@ -896,10 +896,10 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) amrex::Real cc_y = overlap_corner[1] + iv[1]*dx[1] + 0.5*dx[1] ; amrex::Real cc_z = overlap_corner[2] + iv[2]*dx[2] + 0.5*dx[2] ; // get spherical r, theta, phi - amrex::Real cc_rad = std::sqrt( (cc_x-xc)*(cc_x-xc) + amrex::Real cc_rad = std::sqrt( (cc_x-xc)*(cc_x-xc) + (cc_y-yc)*(cc_y-yc) + (cc_z-zc)*(cc_z-zc)); - amrex::Real cc_theta = 0; + amrex::Real cc_theta = 0; if (cc_rad > 0 ) { cc_theta = std::acos((cc_z-xc)/cc_rad); } @@ -945,7 +945,7 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) } } } - else + else { p.id() = -1; continue; @@ -2229,7 +2229,7 @@ PhysicalParticleContainer::getPairGenerationFilterFunc () #ifdef PULSAR void PhysicalParticleContainer::PulsarParticleInjection() { - + AddPlasma( 0 ); } @@ -2257,7 +2257,7 @@ void PhysicalParticleContainer::PulsarParticleRemoval() { ParticleType* pp = pti.GetArrayOfStructs()().data(); amrex::ParallelFor(pti.numParticles(), [=] AMREX_GPU_DEVICE (long i) { - + Real r = std::sqrt((xp_data[i]-xc)*(xp_data[i]-xc) + (yp_data[i]-yc)*(yp_data[i]-yc) + (zp_data[i]-zc)*(zp_data[i]-zc)); From 16d6993afa0b0943a46c80526e0543154575f97b Mon Sep 17 00:00:00 2001 From: "Donald E. Willcox" Date: Thu, 23 Jan 2020 18:20:36 -0800 Subject: [PATCH 036/120] Rename pulsar analysis scripts to make the WarpX style checker happy. --- .../pulsar/{pulsar_vis.py => analysis_pulsar_vis.py} | 0 .../pulsar/{pulsar_viz.ipynb => analysis_pulsar_viz.ipynb} | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename Examples/Physics_applications/pulsar/{pulsar_vis.py => analysis_pulsar_vis.py} (100%) rename Examples/Physics_applications/pulsar/{pulsar_viz.ipynb => analysis_pulsar_viz.ipynb} (100%) diff --git a/Examples/Physics_applications/pulsar/pulsar_vis.py b/Examples/Physics_applications/pulsar/analysis_pulsar_vis.py similarity index 100% rename from Examples/Physics_applications/pulsar/pulsar_vis.py rename to Examples/Physics_applications/pulsar/analysis_pulsar_vis.py diff --git a/Examples/Physics_applications/pulsar/pulsar_viz.ipynb b/Examples/Physics_applications/pulsar/analysis_pulsar_viz.ipynb similarity index 100% rename from Examples/Physics_applications/pulsar/pulsar_viz.ipynb rename to Examples/Physics_applications/pulsar/analysis_pulsar_viz.ipynb From aace0ea2720a335ac604f0bc2ac4c21d9c494805 Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Thu, 23 Jan 2020 19:26:21 -0800 Subject: [PATCH 037/120] fixing an error in rho_GJ calculation --- Source/Particles/PhysicalParticleContainer.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Source/Particles/PhysicalParticleContainer.cpp b/Source/Particles/PhysicalParticleContainer.cpp index 201ff9447a3..e29d06640f7 100644 --- a/Source/Particles/PhysicalParticleContainer.cpp +++ b/Source/Particles/PhysicalParticleContainer.cpp @@ -920,8 +920,8 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) *cc_rad*s_theta*s_theta; Real Er_ext = omega*PulsarParm::B_star*cc_rad*(1.0-3.0*c_theta*c_theta); Er_ext += (2.0/3.0)*omega*PulsarParm::B_star*cc_rad; - amrex::Real rho_GJ = 2.*PhysConst::ep0*PulsarParm::B_star*omega* - cc_rad*(1.0-3.0*c_theta*c_theta)*PulsarParm::rhoGJ_scale; + amrex::Real rho_GJ = 2*PhysConst::ep0*PulsarParm::B_star*omega* + (1.0-3.0*c_theta*c_theta)*PulsarParm::rhoGJ_scale; int ii = Ex_lo.x + iv[0]; int jj = Ex_lo.y + iv[1]; int kk = Ex_lo.z + iv[2]; From ffdfea3f594b5c1d60491433675cbe640d549f2f Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Tue, 10 Mar 2020 16:40:03 -0700 Subject: [PATCH 038/120] Upsating GetPosition() based on recent changes in master branch --- .../Particles/PhysicalParticleContainer.cpp | 33 +++++++++---------- 1 file changed, 15 insertions(+), 18 deletions(-) diff --git a/Source/Particles/PhysicalParticleContainer.cpp b/Source/Particles/PhysicalParticleContainer.cpp index e29d06640f7..8703ff506a5 100644 --- a/Source/Particles/PhysicalParticleContainer.cpp +++ b/Source/Particles/PhysicalParticleContainer.cpp @@ -1063,9 +1063,7 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) #ifdef PULSAR if (PulsarParm::EB_external == 1) { - Real* const AMREX_RESTRICT xp_data = xp.dataPtr(); - Real* const AMREX_RESTRICT yp_data = yp.dataPtr(); - Real* const AMREX_RESTRICT zp_data = zp.dataPtr(); + const auto GetPosition = GetParticlePosition(pti); Real* const AMREX_RESTRICT Exp_data = Exp.dataPtr(); Real* const AMREX_RESTRICT Eyp_data = Eyp.dataPtr(); Real* const AMREX_RESTRICT Ezp_data = Ezp.dataPtr(); @@ -1075,10 +1073,11 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) Real time = warpx.gett_new(lev); amrex::ParallelFor(pti.numParticles(), [=] AMREX_GPU_DEVICE (long i) { - // spherical r, theta, phi, and cylidrical r - PulsarParm::PulsarEBField(xp_data[i],yp_data[i],zp_data[i], - Exp_data[i],Eyp_data[i],Ezp_data[i], - Bxp_data[i],Byp_data[i],Bzp_data[i],time); + ParticleReal x, y, z; + GetPosition(i, x, y, z); + PulsarParm::PulsarEBField(x, y, z, + Exp_data[i],Eyp_data[i],Ezp_data[i], + Bxp_data[i],Byp_data[i],Bzp_data[i],time); }); } #endif @@ -2247,23 +2246,21 @@ void PhysicalParticleContainer::PulsarParticleRemoval() { #endif for (WarpXParIter pti(*this, lev); pti.isValid(); ++pti) { - pti.GetPosition(m_xp[thread_num], m_yp[thread_num], m_zp[thread_num]); - Real* const AMREX_RESTRICT xp_data = m_xp[thread_num].dataPtr(); - Real* const AMREX_RESTRICT yp_data = m_yp[thread_num].dataPtr(); - Real* const AMREX_RESTRICT zp_data = m_zp[thread_num].dataPtr(); + const auto GetPosition = GetParticlePosition(pti); Real xc = PulsarParm::center_star[0]; Real yc = PulsarParm::center_star[1]; Real zc = PulsarParm::center_star[2]; ParticleType* pp = pti.GetArrayOfStructs()().data(); amrex::ParallelFor(pti.numParticles(), [=] AMREX_GPU_DEVICE (long i) { - - Real r = std::sqrt((xp_data[i]-xc)*(xp_data[i]-xc) - + (yp_data[i]-yc)*(yp_data[i]-yc) - + (zp_data[i]-zc)*(zp_data[i]-zc)); - if (r<=(PulsarParm::R_star-PulsarParm::dR_star)) { - pp[i].id() = -1; - } + ParticleReal x, y, z; + GetPosition(i, x, y, z); + Real r = std::sqrt((x-xc)*(x-xc) + + (y-yc)*(y-yc) + + (z-zc)*(z-zc)); + if (r<=(PulsarParm::R_star-PulsarParm::dR_star)) { + pp[i].id() = -1; + } }); } } From 0cb96031f068413794c00ddfaa9e5e7b034d10f5 Mon Sep 17 00:00:00 2001 From: "Donald E. Willcox" Date: Tue, 21 Jan 2020 15:04:37 -0800 Subject: [PATCH 039/120] Damp electric fields internal to the pulsar when compiling with PULSAR on. --- Source/Evolve/WarpXEvolve.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Source/Evolve/WarpXEvolve.cpp b/Source/Evolve/WarpXEvolve.cpp index 5a835b59c5d..8a1e8997b5e 100644 --- a/Source/Evolve/WarpXEvolve.cpp +++ b/Source/Evolve/WarpXEvolve.cpp @@ -22,7 +22,7 @@ #include #ifdef PULSAR -#include + #include "Particles/PulsarParameters.H" #endif using namespace amrex; From bfd0e3f6b834f2ef5ff9edbf751401c79ddf392c Mon Sep 17 00:00:00 2001 From: "Donald E. Willcox" Date: Tue, 21 Jan 2020 15:56:56 -0800 Subject: [PATCH 040/120] Separate out cartesian ijk -> spherical radius into a utility function so it can be used elsewhere. --- Source/Particles/PulsarParameters.H | 27 ++++++++++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) diff --git a/Source/Particles/PulsarParameters.H b/Source/Particles/PulsarParameters.H index de591988a9f..54d24b19218 100644 --- a/Source/Particles/PulsarParameters.H +++ b/Source/Particles/PulsarParameters.H @@ -60,6 +60,31 @@ namespace PulsarParm } } + namespace Spherical + { + AMREX_GPU_HOST_DEVICE AMREX_INLINE + amrex::Real r(int i, int j, int k, amrex::GeometryData const& geom) + { + const auto domain_box = geom.Domain(); + const auto domain_ilo = amrex::lbound(domain_box); + const auto domain_xlo = geom.ProbLo(); + const auto domain_xhi = geom.ProbHi(); + const auto domain_dx = geom.CellSize(); + + const amrex::Real x = domain_xlo[0] + (i - domain_ilo.x + 0.5) * domain_dx[0]; + const amrex::Real y = domain_xlo[1] + (j - domain_ilo.y + 0.5) * domain_dx[1]; + const amrex::Real z = domain_xlo[2] + (k - domain_ilo.z + 0.5) * domain_dx[2]; + + const amrex::Real xc = 0.5 * (domain_xlo[0] + domain_xhi[0]); + const amrex::Real yc = 0.5 * (domain_xlo[1] + domain_xhi[1]); + const amrex::Real zc = 0.5 * (domain_xlo[2] + domain_xhi[2]); + + const amrex::Real r = std::sqrt((x-xc)*(x-xc) + (y-yc)*(y-yc) + (z-zc)*(z-zc)); + + return r; + } + } + AMREX_GPU_HOST_DEVICE AMREX_INLINE amrex::Real Omega(const amrex::Real time) { @@ -82,7 +107,7 @@ namespace PulsarParm // Fd(0) ~ 0 // Fd(R_star) ~ 1 - const amrex::Real Fd = std::tanh(damping_scale * (r / R_star - 1)) + 1; + const amrex::Real Fd = std::tanh(damping_scale * (r / R_star - 1.0)) + 1.0; Efield(i, j, k) = Efield(i, j, k) * Fd; } } From 21a52decd226bf071946c036b292273d6cc7b919 Mon Sep 17 00:00:00 2001 From: "Donald E. Willcox" Date: Tue, 21 Jan 2020 18:51:51 -0800 Subject: [PATCH 041/120] Rename damping function, damp in domain [0, R_star-dR_star]. Normalize argument to tanh in damping formula. --- Source/Particles/PulsarParameters.H | 1 + 1 file changed, 1 insertion(+) diff --git a/Source/Particles/PulsarParameters.H b/Source/Particles/PulsarParameters.H index 54d24b19218..5094c5c8b0b 100644 --- a/Source/Particles/PulsarParameters.H +++ b/Source/Particles/PulsarParameters.H @@ -100,6 +100,7 @@ namespace PulsarParm void DampEField(int i, int j, int k, amrex::GeometryData const& geom, amrex::Array4 const& Efield) { const amrex::Real r = Spherical::r(i, j, k, geom); + const amrex::Real R_inner = PulsarParm::R_star - PulsarParm::dR_star; if (r < R_star) { // Damping function: Fd = tanh(damping_scale * (r / R_star - 1)) + 1 From ea14d503e7b58b5a09c74407db9bd5dc3ac86052 Mon Sep 17 00:00:00 2001 From: "Donald E. Willcox" Date: Wed, 22 Jan 2020 21:05:37 -0800 Subject: [PATCH 042/120] Add PulsarParm::Omega(t) function that returns omega(t) depending on ramp_omega_time input parameter. If ramp_omega_time < 0, PulsarParm::Omega(t) = omega_star. --- Source/Particles/PulsarParameters.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/Source/Particles/PulsarParameters.cpp b/Source/Particles/PulsarParameters.cpp index d0807b3e54c..2699f6978c4 100644 --- a/Source/Particles/PulsarParameters.cpp +++ b/Source/Particles/PulsarParameters.cpp @@ -51,5 +51,4 @@ namespace PulsarParm amrex::Print() << " pulsar ninj fraction " << Ninj_fraction << "\n"; amrex::Print() << " pulsar rhoGJ scaling " << rhoGJ_scale << "\n"; } - } From bdf8ee327b27fc696ea13bb3ef3c2e04c7145976 Mon Sep 17 00:00:00 2001 From: "Donald E. Willcox" Date: Thu, 23 Jan 2020 16:54:46 -0800 Subject: [PATCH 043/120] Change form of damping function to tanh(damping_scale * (r/R_star-1)) + 1 so the damping factor at r=R_star is 1.0. Add pulsar.damping_scale as an input parameter defaulted to a reasonable value of 10. --- Source/Particles/PulsarParameters.H | 1 - 1 file changed, 1 deletion(-) diff --git a/Source/Particles/PulsarParameters.H b/Source/Particles/PulsarParameters.H index 5094c5c8b0b..54d24b19218 100644 --- a/Source/Particles/PulsarParameters.H +++ b/Source/Particles/PulsarParameters.H @@ -100,7 +100,6 @@ namespace PulsarParm void DampEField(int i, int j, int k, amrex::GeometryData const& geom, amrex::Array4 const& Efield) { const amrex::Real r = Spherical::r(i, j, k, geom); - const amrex::Real R_inner = PulsarParm::R_star - PulsarParm::dR_star; if (r < R_star) { // Damping function: Fd = tanh(damping_scale * (r / R_star - 1)) + 1 From cd59aab9cb206f3be8e2806defd17f889472e89d Mon Sep 17 00:00:00 2001 From: "Donald E. Willcox" Date: Thu, 23 Jan 2020 17:01:04 -0800 Subject: [PATCH 044/120] Add a python script for making plots and a gif from a set of plotfiles. --- .../Physics_applications/pulsar/pulsar_vis.py | 54 +++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 Examples/Physics_applications/pulsar/pulsar_vis.py diff --git a/Examples/Physics_applications/pulsar/pulsar_vis.py b/Examples/Physics_applications/pulsar/pulsar_vis.py new file mode 100644 index 00000000000..3694a1f91e5 --- /dev/null +++ b/Examples/Physics_applications/pulsar/pulsar_vis.py @@ -0,0 +1,54 @@ +import yt +import os +import glob +import argparse + +parser = argparse.ArgumentParser() +parser.add_argument("-f", "--plotfile", type=str, help="Path to single input plotfile to visualize.") +parser.add_argument("-d", "--dir", type=str, help="Path to input plotfile directory to visualize.") + +args = parser.parse_args() + +def visualize(plt, annotate_particles=True): + ds = yt.load(plt) + sl = yt.SlicePlot(ds, 0, 'Ez', aspect=1) # Create a sliceplot object + if annotate_particles: + sl.annotate_particles(width=(2.e3, 'm'),ptype="plasma_p",col='b',p_size=5.0) + sl.annotate_particles(width=(2.e3, 'm'),ptype="plasma_e",col='r',p_size=5.0) + sl.annotate_streamlines("Ey", "Ez", plot_args={"color": "black"}) + sl.annotate_grids() # Show grids + sl.annotate_sphere([90000.0, 90000.0, 90000.0], radius=12000.0, + circle_args={'color':'white', 'linewidth':2}) + out_name = os.path.join(os.path.dirname(plt), "pulsar_{}.png".format(os.path.basename(plt))) + sl.save(out_name) + +if __name__ == "__main__": + yt.funcs.mylog.setLevel(50) + if args.dir: + failed = [] + plotfiles = glob.glob(os.path.join(args.dir, "plt" + "[0-9]"*5)) + for pf in plotfiles: + try: + visualize(pf) + except: + # plotfile 0 may not have particles, so turn off annotations if we first failed + try: + visualize(pf, annotate_particles=False) + except: + failed.append(pf) + pass + + if len(failed) > 0: + print("Visualization failed for the following plotfiles:") + for fp in failed: + print(fp) + else: + print("No plots failed, creating a gif ...") + input_files = os.path.join(args.dir, "*.png") + output_gif = os.path.join(args.dir, "pulsar.gif") + os.system("convert -delay 20 -loop 0 {} {}".format(input_files, output_gif)) + + elif args.plotfile: + visualize(args.plotfile) + else: + print("Supply either -f or -d options for visualization. Use the -h option to see help.") From b724bcb98ce526a65219c83d057dec692ff6ab46 Mon Sep 17 00:00:00 2001 From: "Donald E. Willcox" Date: Thu, 12 Mar 2020 18:06:26 -0700 Subject: [PATCH 045/120] Undo line removal. --- Source/Evolve/WarpXEvolve.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/Source/Evolve/WarpXEvolve.cpp b/Source/Evolve/WarpXEvolve.cpp index 8a1e8997b5e..fdad28cc9f8 100644 --- a/Source/Evolve/WarpXEvolve.cpp +++ b/Source/Evolve/WarpXEvolve.cpp @@ -25,6 +25,7 @@ #include "Particles/PulsarParameters.H" #endif + using namespace amrex; void From a2edc1f826ffeab4f32a8ebe27f6e2cc2aa2283a Mon Sep 17 00:00:00 2001 From: "Donald E. Willcox" Date: Thu, 12 Mar 2020 18:07:16 -0700 Subject: [PATCH 046/120] Undo removal of newline. --- Source/Particles/PulsarParameters.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/Source/Particles/PulsarParameters.cpp b/Source/Particles/PulsarParameters.cpp index 2699f6978c4..d0807b3e54c 100644 --- a/Source/Particles/PulsarParameters.cpp +++ b/Source/Particles/PulsarParameters.cpp @@ -51,4 +51,5 @@ namespace PulsarParm amrex::Print() << " pulsar ninj fraction " << Ninj_fraction << "\n"; amrex::Print() << " pulsar rhoGJ scaling " << rhoGJ_scale << "\n"; } + } From aeae46568f028fdf0f66e50baaadcbe934fc8ad9 Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Wed, 24 Jun 2020 20:33:44 -0700 Subject: [PATCH 047/120] fix compilation error --- Source/Evolve/WarpXEvolve.cpp | 12 ++++----- .../Particles/PhysicalParticleContainer.cpp | 3 ++- Source/Particles/PulsarParameters.H | 25 ------------------- Source/Particles/PulsarParameters.cpp | 2 +- 4 files changed, 8 insertions(+), 34 deletions(-) diff --git a/Source/Evolve/WarpXEvolve.cpp b/Source/Evolve/WarpXEvolve.cpp index fdad28cc9f8..49b2e02ded1 100644 --- a/Source/Evolve/WarpXEvolve.cpp +++ b/Source/Evolve/WarpXEvolve.cpp @@ -18,13 +18,11 @@ # include "FieldSolver/SpectralSolver/SpectralSolver.H" #endif -#include -#include - #ifdef PULSAR #include "Particles/PulsarParameters.H" #endif - +#include +#include using namespace amrex; @@ -187,9 +185,9 @@ WarpX::Evolve (int numsteps) #endif for ( MFIter mfi(*Ex, TilingIfNotGPU()); mfi.isValid(); ++mfi ) { - const Box& tex = mfi.tilebox(Ex_nodal_flag); - const Box& tey = mfi.tilebox(Ey_nodal_flag); - const Box& tez = mfi.tilebox(Ez_nodal_flag); + const Box& tex = mfi.tilebox( Ex->ixType().toIntVect() ); + const Box& tey = mfi.tilebox( Ey->ixType().toIntVect() ); + const Box& tez = mfi.tilebox( Ez->ixType().toIntVect() ); auto const& Exfab = Ex->array(mfi); auto const& Eyfab = Ey->array(mfi); diff --git a/Source/Particles/PhysicalParticleContainer.cpp b/Source/Particles/PhysicalParticleContainer.cpp index 8703ff506a5..e8afae676f6 100644 --- a/Source/Particles/PhysicalParticleContainer.cpp +++ b/Source/Particles/PhysicalParticleContainer.cpp @@ -609,7 +609,8 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) const MultiFab& Ex_mf = WarpX::GetInstance().getEfield(lev,0); const MultiFab& Ey_mf = WarpX::GetInstance().getEfield(lev,1); const MultiFab& Ez_mf = WarpX::GetInstance().getEfield(lev,2); - const MultiFab& rho_mf = WarpX::GetInstance().getRho(lev); + //const MultiFab& rho_mf = WarpX::GetInstance().getRho(lev); + const MultiFab& rho_mf = WarpX::GetInstance().getrho_fp(lev); const Real dt = WarpX::GetInstance().getdt(0); #endif diff --git a/Source/Particles/PulsarParameters.H b/Source/Particles/PulsarParameters.H index 54d24b19218..6f49ec42a96 100644 --- a/Source/Particles/PulsarParameters.H +++ b/Source/Particles/PulsarParameters.H @@ -60,31 +60,6 @@ namespace PulsarParm } } - namespace Spherical - { - AMREX_GPU_HOST_DEVICE AMREX_INLINE - amrex::Real r(int i, int j, int k, amrex::GeometryData const& geom) - { - const auto domain_box = geom.Domain(); - const auto domain_ilo = amrex::lbound(domain_box); - const auto domain_xlo = geom.ProbLo(); - const auto domain_xhi = geom.ProbHi(); - const auto domain_dx = geom.CellSize(); - - const amrex::Real x = domain_xlo[0] + (i - domain_ilo.x + 0.5) * domain_dx[0]; - const amrex::Real y = domain_xlo[1] + (j - domain_ilo.y + 0.5) * domain_dx[1]; - const amrex::Real z = domain_xlo[2] + (k - domain_ilo.z + 0.5) * domain_dx[2]; - - const amrex::Real xc = 0.5 * (domain_xlo[0] + domain_xhi[0]); - const amrex::Real yc = 0.5 * (domain_xlo[1] + domain_xhi[1]); - const amrex::Real zc = 0.5 * (domain_xlo[2] + domain_xhi[2]); - - const amrex::Real r = std::sqrt((x-xc)*(x-xc) + (y-yc)*(y-yc) + (z-zc)*(z-zc)); - - return r; - } - } - AMREX_GPU_HOST_DEVICE AMREX_INLINE amrex::Real Omega(const amrex::Real time) { diff --git a/Source/Particles/PulsarParameters.cpp b/Source/Particles/PulsarParameters.cpp index d0807b3e54c..0e16a2d0477 100644 --- a/Source/Particles/PulsarParameters.cpp +++ b/Source/Particles/PulsarParameters.cpp @@ -1,4 +1,4 @@ -#include +#include "PulsarParameters.H" #include #include #include From 2badefbf592ff4c137c1dfdb5eff2be9617bf706 Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Wed, 24 Jun 2020 21:30:00 -0700 Subject: [PATCH 048/120] some more compilation error --- Source/WarpX.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Source/WarpX.cpp b/Source/WarpX.cpp index e78e8474d29..5ff9325493a 100644 --- a/Source/WarpX.cpp +++ b/Source/WarpX.cpp @@ -20,7 +20,7 @@ #include "Utils/WarpXAlgorithmSelection.H" #include "Utils/WarpXProfilerWrapper.H" #ifdef PULSAR -# include "Particles/PulsarParameters.H" +#include "Particles/PulsarParameters.H" #endif #include From 8c0931bb952c5175eb2789ccfa18f81b46583fc3 Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Wed, 24 Jun 2020 21:59:35 -0700 Subject: [PATCH 049/120] Calling External E and B for pulsar from GetExternal functions --- Source/Particles/Gather/GetExternalFields.H | 23 ++- Source/Particles/Gather/GetExternalFields.cpp | 16 ++ Source/Particles/PulsarParameters.H | 182 +++++++++++++++++- 3 files changed, 216 insertions(+), 5 deletions(-) diff --git a/Source/Particles/Gather/GetExternalFields.H b/Source/Particles/Gather/GetExternalFields.H index 4bf520be955..de2cec09b38 100644 --- a/Source/Particles/Gather/GetExternalFields.H +++ b/Source/Particles/Gather/GetExternalFields.H @@ -3,12 +3,19 @@ #include "Particles/WarpXParticleContainer.H" #include "Particles/Pusher/GetAndSetPosition.H" +#ifdef PULSAR + #include "Particles/PulsarParameters.H" +#endif #include #include -enum ExternalFieldInitType { Constant, Parser }; +enum ExternalFieldInitType { Constant, Parser +#ifdef PULSAR + , Pulsar_Efield, Pulsar_Bfield +#endif + }; /** \brief Base class for functors that assign external * field values (E or B) to particles. @@ -45,6 +52,20 @@ struct GetExternalField field_y += m_yfield_partparser(x, y, z, m_time); field_z += m_zfield_partparser(x, y, z, m_time); } +#ifdef PULSAR + else if (m_type == Pulsar_Efield) + { + amrex::ParticleReal x, y, z; + m_get_position(i, x, y, z); + PulsarParm::PulsarEField(x, y, z, field_x, field_y, field_z, m_time); + } + else if (m_type == Pulsar_Bfield) + { + amrex::ParticleReal x, y, z; + m_get_position(i, x, y, z); + PulsarParm::PulsarBField(x, y, z, field_x, field_y, field_z, m_time); + } +#endif else { amrex::Abort("ExternalFieldInitType not known!!! \n"); diff --git a/Source/Particles/Gather/GetExternalFields.cpp b/Source/Particles/Gather/GetExternalFields.cpp index c1fbe49daca..9bd1be32ea5 100644 --- a/Source/Particles/Gather/GetExternalFields.cpp +++ b/Source/Particles/Gather/GetExternalFields.cpp @@ -21,6 +21,14 @@ GetExternalEField::GetExternalEField (const WarpXParIter& a_pti, int a_offset) n m_yfield_partparser = getParser(mypc.m_Ey_particle_parser); m_zfield_partparser = getParser(mypc.m_Ez_particle_parser); } +#ifdef PULSAR + else if (PulsarParm::EB_external == 1) + { + m_type = Pulsar_Efield; + m_time = warpx.gett_new(a_pti.GetLevel()); + m_get_position = GetParticlePosition(a_pti, a_offset); + } +#endif } GetExternalBField::GetExternalBField (const WarpXParIter& a_pti, int a_offset) noexcept @@ -43,4 +51,12 @@ GetExternalBField::GetExternalBField (const WarpXParIter& a_pti, int a_offset) n m_yfield_partparser = getParser(mypc.m_By_particle_parser); m_zfield_partparser = getParser(mypc.m_Bz_particle_parser); } +#ifdef PULSAR + else if (PulsarParm::EB_external == 1) + { + m_type = Pulsar_Bfield; + m_time = warpx.gett_new(a_pti.GetLevel()); + m_get_position = GetParticlePosition(a_pti, a_offset); + } +#endif } diff --git a/Source/Particles/PulsarParameters.H b/Source/Particles/PulsarParameters.H index 6f49ec42a96..711709cfb71 100644 --- a/Source/Particles/PulsarParameters.H +++ b/Source/Particles/PulsarParameters.H @@ -29,11 +29,185 @@ namespace PulsarParm extern AMREX_GPU_DEVICE_MANAGED int verbose; void ReadParameters(); + + AMREX_GPU_HOST_DEVICE AMREX_INLINE + void PulsarEField(const amrex::ParticleReal xp, const amrex::ParticleReal yp, + const amrex::ParticleReal zp, + amrex::ParticleReal &Exp, amrex::ParticleReal &Eyp, + amrex::ParticleReal &Ezp, + amrex::Real time) + { + // spherical r, theta, phi + const amrex::Real xc = center_star[0]; + const amrex::Real yc = center_star[1]; + const amrex::Real zc = center_star[2]; + const amrex::Real r = std::sqrt( (xp-xc)*(xp-xc) + (yp-yc)*(yp-yc) + (zp-zc)*(zp-zc) ); + const amrex::Real phi = std::atan2((yp-yc),(xp-xc)); + amrex::Real theta = 0.0; + if (r > 0) { + theta = std::acos((zp-zc)/r); + } + const amrex::Real c_theta = std::cos(theta); + const amrex::Real s_theta = std::sin(theta); + const amrex::Real c_phi = std::cos(phi); + const amrex::Real s_phi = std::sin(phi); + amrex::Real omega = omega_star; + // ramping up omega + if (time < 2.0e-4) { + omega = omega_star*time/2.0e-4; + } + + if (r= R_star ) { + amrex::Real r_ratio = R_star/r; + amrex::Real r3 = r_ratio*r_ratio*r_ratio; + // Taking derivative of phi given in eq 30 of Michel and Li + amrex::Real Er = B_star*omega*R_star*r_ratio*r3*(1.0-3.0*c_theta*c_theta); + if (E_external_monopole == 1) { + Er += (2.0/3.0)*omega*B_star*R_star*r_ratio*r_ratio; + } + amrex::Real Etheta = (-1.0)*B_star*omega*R_star*r_ratio*r3*(2.0*s_theta*c_theta); + + Exp = Er*s_theta*c_phi + Etheta*c_theta*c_phi; + Eyp = Er*s_theta*s_phi + Etheta*c_theta*s_phi; + Ezp = Er*c_theta - Etheta*s_theta; + } + } + + AMREX_GPU_HOST_DEVICE AMREX_INLINE - void PulsarEBField(amrex::Real xp, amrex::Real yp, amrex::Real zp, - amrex::Real &Exp, amrex::Real &Eyp, amrex::Real &Ezp, - amrex::Real &Bxp, amrex::Real &Byp, amrex::Real &Bzp, - amrex::Real time); + void PulsarBField(const amrex::ParticleReal xp, const amrex::ParticleReal yp, + const amrex::ParticleReal zp, + amrex::ParticleReal &Bxp, amrex::ParticleReal &Byp, + amrex::ParticleReal &Bzp, + amrex::Real time) + { + // spherical r, theta, phi + const amrex::Real xc = center_star[0]; + const amrex::Real yc = center_star[1]; + const amrex::Real zc = center_star[2]; + const amrex::Real r = std::sqrt( (xp-xc)*(xp-xc) + (yp-yc)*(yp-yc) + (zp-zc)*(zp-zc) ); + const amrex::Real phi = std::atan2((yp-yc),(xp-xc)); + amrex::Real theta = 0.0; + if (r > 0) { + theta = std::acos((zp-zc)/r); + } + const amrex::Real c_theta = std::cos(theta); + const amrex::Real s_theta = std::sin(theta); + const amrex::Real c_phi = std::cos(phi); + const amrex::Real s_phi = std::sin(phi); + amrex::Real omega = omega_star; + // ramping up omega + if (time < 2.0e-4) { + omega = omega_star*time/2.0e-4; + } + + if (r= R_star ) { + amrex::Real r_ratio = R_star/r; + amrex::Real r3 = r_ratio*r_ratio*r_ratio; + // Taking derivative of phi given in eq 30 of Michel and Li + amrex::Real Br = 2.0*B_star*r3*c_theta; + amrex::Real Btheta = B_star*r3*s_theta; + + Bxp = Br*s_theta*c_phi + Btheta*c_theta*c_phi; + Byp = Br*s_theta*s_phi + Btheta*c_theta*s_phi; + Bzp = Br*c_theta - Btheta*s_theta; + } + } + +// AMREX_GPU_HOST_DEVICE AMREX_INLINE +// void PulsarEBField(amrex::Real xp, amrex::Real yp, amrex::Real zp, +// amrex::Real &Exp, amrex::Real &Eyp, amrex::Real &Ezp, +// amrex::Real &Bxp, amrex::Real &Byp, amrex::Real &Bzp, +// amrex::Real time) +// { +// // spherical r, theta, phi +// const amrex::Real xc = center_star[0]; +// const amrex::Real yc = center_star[1]; +// const amrex::Real zc = center_star[2]; +// const amrex::Real r = std::sqrt( (xp-xc)*(xp-xc) + (yp-yc)*(yp-yc) + (zp-zc)*(zp-zc) ); +// const amrex::Real phi = std::atan2((yp-yc),(xp-xc)); +// amrex::Real theta = 0.0; +// if (r > 0) { +// theta = std::acos((zp-zc)/r); +// } +// const amrex::Real c_theta = std::cos(theta); +// const amrex::Real s_theta = std::sin(theta); +// const amrex::Real c_phi = std::cos(phi); +// const amrex::Real s_phi = std::sin(phi); +// amrex::Real omega = omega_star; +// // ramping up omega +// if (time < 2.0e-4) { +// omega = omega_star*time/2.0e-4; +// } +// +// if (r= R_star ) { +// amrex::Real r_ratio = R_star/r; +// amrex::Real r3 = r_ratio*r_ratio*r_ratio; +// // Taking derivative of phi given in eq 30 of Michel and Li +// amrex::Real Er = B_star*omega*R_star*r_ratio*r3*(1.0-3.0*c_theta*c_theta); +// if (E_external_monopole == 1) { +// Er += (2.0/3.0)*omega*B_star*R_star*r_ratio*r_ratio; +// } +// amrex::Real Etheta = (-1.0)*B_star*omega*R_star*r_ratio*r3*(2.0*s_theta*c_theta); +// +// Exp = Er*s_theta*c_phi + Etheta*c_theta*c_phi; +// Eyp = Er*s_theta*s_phi + Etheta*c_theta*s_phi; +// Ezp = Er*c_theta - Etheta*s_theta; +// +// amrex::Real Br = 2.0*B_star*r3*c_theta; +// amrex::Real Btheta = B_star*r3*s_theta; +// +// Bxp = Br*s_theta*c_phi + Btheta*c_theta*c_phi; +// Byp = Br*s_theta*s_phi + Btheta*c_theta*s_phi; +// Bzp = Br*c_theta - Btheta*s_theta; +// } +// } namespace Spherical { From fabcd9977d29fc3d84627e815be6707a13941d68 Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Thu, 9 Jul 2020 10:11:33 -0700 Subject: [PATCH 050/120] a few fixes in the getexternalEB and addplasma to ensure test works --- .../pulsar/analysis_pulsar_viz.ipynb | 155 ++++++---- .../pulsar/inputs.corotating.3d.PM | 22 +- Source/Particles/Gather/GetExternalFields.cpp | 4 +- .../Particles/PhysicalParticleContainer.cpp | 19 +- Source/Particles/PulsarParameters.H | 269 +++++++++--------- Source/Particles/PulsarParameters.cpp | 89 +++--- 6 files changed, 304 insertions(+), 254 deletions(-) diff --git a/Examples/Physics_applications/pulsar/analysis_pulsar_viz.ipynb b/Examples/Physics_applications/pulsar/analysis_pulsar_viz.ipynb index 57ef79c1599..febea7950aa 100644 --- a/Examples/Physics_applications/pulsar/analysis_pulsar_viz.ipynb +++ b/Examples/Physics_applications/pulsar/analysis_pulsar_viz.ipynb @@ -15,7 +15,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -43,19 +43,68 @@ }, { "cell_type": "code", - "execution_count": 149, + "execution_count": 36, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[('all', 'particle_cpu'),\n", + " ('all', 'particle_id'),\n", + " ('all', 'particle_momentum_x'),\n", + " ('all', 'particle_momentum_y'),\n", + " ('all', 'particle_momentum_z'),\n", + " ('all', 'particle_position_x'),\n", + " ('all', 'particle_position_y'),\n", + " ('all', 'particle_position_z'),\n", + " ('all', 'particle_weight'),\n", + " ('boxlib', 'Bx'),\n", + " ('boxlib', 'By'),\n", + " ('boxlib', 'Bz'),\n", + " ('boxlib', 'Ex'),\n", + " ('boxlib', 'Ey'),\n", + " ('boxlib', 'Ez'),\n", + " ('boxlib', 'divE'),\n", + " ('boxlib', 'jx'),\n", + " ('boxlib', 'jy'),\n", + " ('boxlib', 'jz'),\n", + " ('boxlib', 'part_per_cell'),\n", + " ('boxlib', 'rho'),\n", + " ('plasma_e', 'particle_cpu'),\n", + " ('plasma_e', 'particle_id'),\n", + " ('plasma_e', 'particle_momentum_x'),\n", + " ('plasma_e', 'particle_momentum_y'),\n", + " ('plasma_e', 'particle_momentum_z'),\n", + " ('plasma_e', 'particle_position_x'),\n", + " ('plasma_e', 'particle_position_y'),\n", + " ('plasma_e', 'particle_position_z'),\n", + " ('plasma_e', 'particle_weight'),\n", + " ('plasma_p', 'particle_cpu'),\n", + " ('plasma_p', 'particle_id'),\n", + " ('plasma_p', 'particle_momentum_x'),\n", + " ('plasma_p', 'particle_momentum_y'),\n", + " ('plasma_p', 'particle_momentum_z'),\n", + " ('plasma_p', 'particle_position_x'),\n", + " ('plasma_p', 'particle_position_y'),\n", + " ('plasma_p', 'particle_position_z'),\n", + " ('plasma_p', 'particle_weight')]" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "\n", - "ds = yt.load( './plotfiles/plt00090/' ) # Create a dataset object\n", - "filenum = 10\n", - "#ds.field_list" + "ds = yt.load( './diags/plt00010/' ) # Create a dataset object\n", + "filenum = 90\n", + "ds.field_list" ] }, { "cell_type": "code", - "execution_count": 150, + "execution_count": 37, "metadata": { "scrolled": false }, @@ -64,17 +113,19 @@ "name": "stderr", "output_type": "stream", "text": [ - "/usr/local/lib/python3.5/dist-packages/yt-3.6.dev0-py3.5-linux-x86_64.egg/yt/units/yt_array.py:1400: RuntimeWarning: invalid value encountered in true_divide\n", + "/usr/local/lib/python3.7/dist-packages/yt-3.7.dev0-py3.7-linux-x86_64.egg/yt/visualization/base_plot_types.py:222: MatplotlibDeprecationWarning: default base may change from np.e to 10. To suppress this warning specify the base keyword argument.\n", + " vmax=float(np.nanmax(data)))\n", + "/usr/local/lib/python3.7/dist-packages/yt-3.7.dev0-py3.7-linux-x86_64.egg/yt/units/yt_array.py:1417: RuntimeWarning: invalid value encountered in true_divide\n", " out=out, **kwargs)\n" ] }, { "data": { "text/html": [ - "
" + "
" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -83,9 +134,9 @@ ], "source": [ "\n", - "sl = yt.SlicePlot(ds, 0, 'Ez', aspect=1) # Create a sliceplot object\n", - "sl.annotate_particles(width=(2.e3, 'm'),ptype=\"plasma_p\",col='b',p_size=5.0)\n", - "sl.annotate_particles(width=(2.e3, 'm'),ptype=\"plasma_e\",col='r',p_size=5.0)\n", + "sl = yt.SlicePlot(ds, 0, 'Ey', aspect=1) # Create a sliceplot object\n", + "#sl.annotate_particles(width=(2.e3, 'm'),ptype=\"plasma_p\",col='b',p_size=5.0)\n", + "#sl.annotate_particles(width=(2.e3, 'm'),ptype=\"plasma_e\",col='r',p_size=5.0)\n", "sl.annotate_streamlines(\"Ey\", \"Ez\", plot_args={\"color\": \"black\"})\n", "sl.annotate_grids() # Show grids\n", "sl.annotate_sphere([90000.0, 90000.0, 90000.0], radius=12000.0,\n", @@ -96,30 +147,22 @@ }, { "cell_type": "code", - "execution_count": 147, + "execution_count": 26, "metadata": {}, "outputs": [ { - "data": { - "text/html": [ - "
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "['positron_plt10.png']" - ] - }, - "execution_count": 147, - "metadata": {}, - "output_type": "execute_result" + "ename": "YTFieldNotFound", + "evalue": "Could not find field '('plasma_p', 'particle_position_x')' in .", + "output_type": "error", + "traceback": [ + "\u001b[0;31m-----------------------------------------------\u001b[0m", + "\u001b[0;31mYTFieldNotFound\u001b[0mTraceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0myt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mParticlePlot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mds\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'plasma_p'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'particle_position_x'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'plasma_p'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'particle_position_y'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'plasma_p'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'particle_momentum_x'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msave\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"positron_plt\"\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilenum\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;34m\".png\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/yt-3.7.dev0-py3.7-linux-x86_64.egg/yt/visualization/particle_plots.py\u001b[0m in \u001b[0;36mParticlePlot\u001b[0;34m(ds, x_field, y_field, z_fields, color, *args, **kwargs)\u001b[0m\n\u001b[1;32m 509\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mdd\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 510\u001b[0m \u001b[0mdd\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mds\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mall_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 511\u001b[0;31m \u001b[0mx_field\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_determine_fields\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx_field\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 512\u001b[0m \u001b[0my_field\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_determine_fields\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_field\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 513\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/yt-3.7.dev0-py3.7-linux-x86_64.egg/yt/data_objects/data_containers.py\u001b[0m in \u001b[0;36m_determine_fields\u001b[0;34m(self, fields)\u001b[0m\n\u001b[1;32m 1359\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mYTFieldNotParseable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfield\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1360\u001b[0m \u001b[0mftype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfname\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfield\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1361\u001b[0;31m \u001b[0mfinfo\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mds\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_field_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mftype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1362\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfield\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mDerivedField\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1363\u001b[0m \u001b[0mftype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfname\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfield\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/yt-3.7.dev0-py3.7-linux-x86_64.egg/yt/data_objects/static_output.py\u001b[0m in \u001b[0;36m_get_field_info\u001b[0;34m(self, ftype, fname)\u001b[0m\n\u001b[1;32m 737\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_last_finfo\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfield_info\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mftype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 738\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_last_finfo\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 739\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mYTFieldNotFound\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mftype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 740\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 741\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_setup_classes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mYTFieldNotFound\u001b[0m: Could not find field '('plasma_p', 'particle_position_x')' in ." + ] } ], "source": [ @@ -130,16 +173,16 @@ }, { "cell_type": "code", - "execution_count": 148, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/html": [ - "
" + "
" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -148,10 +191,10 @@ { "data": { "text/plain": [ - "['electrons_plt10.png']" + "['electrons_plt90.png']" ] }, - "execution_count": 148, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -165,7 +208,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -186,7 +229,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -196,7 +239,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -217,7 +260,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -234,7 +277,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -271,7 +314,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -307,7 +350,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -345,7 +388,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -503,11 +546,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": { "scrolled": false }, - "outputs": [], + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'Ez_external' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m-----------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mds\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_field\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Ex_external\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mfunction\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mEx_external\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0munits\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m''\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0msampling_type\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"cell\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mds\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_field\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Ey_external\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mfunction\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mEy_external\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0munits\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m''\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0msampling_type\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"cell\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mds\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_field\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Ez_external\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mfunction\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mEz_external\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0munits\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m''\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0msampling_type\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"cell\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0mds\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_field\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Ex_internal\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mfunction\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mEx_internal\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0munits\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m''\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0msampling_type\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"cell\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mds\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_field\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Ey_internal\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mfunction\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mEy_internal\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0munits\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m''\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0msampling_type\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"cell\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'Ez_external' is not defined" + ] + } + ], "source": [ "ds.add_field((\"Ex_external\"),function=Ex_external,units='',sampling_type=\"cell\")\n", "ds.add_field((\"Ey_external\"),function=Ey_external,units='',sampling_type=\"cell\")\n", @@ -670,7 +725,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.2" + "version": "3.7.7" }, "widgets": { "state": { diff --git a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM index a5c8cc525e8..fd1befef30a 100644 --- a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM +++ b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM @@ -13,14 +13,12 @@ ################################# ####### GENERAL PARAMETERS ###### ################################# -max_step = 5000 +max_step = 100 #amr.n_cell = 256 256 256 amr.n_cell = 128 128 128 amr.max_grid_size = 64 amr.blocking_factor = 64 amr.max_level = 0 -amr.plot_file = "plotfiles/plt" -amr.plot_int = 2 geometry.coord_sys = 0 # 0: Cartesian geometry.is_periodic = 0 0 0 # Is periodic? geometry.prob_lo = 0.0 0.0 0.0 @@ -31,11 +29,9 @@ geometry.prob_hi = 180000 180000 180000 ################################# algo.maxwell_fdtd_solver = yee warpx.verbose = 1 -warpx.plot_raw_fields = 0 warpx.do_dive_cleaning = 0 warpx.use_filter = 1 warpx.cfl = .5 -warpx.fields_to_plot = Ex Ey Ez Bx By Bz jx jy jz part_per_cell rho divE my_constants.pi = 3.141592653589793 my_constants.dens = 5.544e6 my_constants.xc = 90000 @@ -129,24 +125,30 @@ plasma_p.momentum_function_uz(x,y,z) = "0.0" plasma_p.do_continuous_injection = 0 plasma_p.density_min = 1E0 +diagnostics.diags_names = plt +plt.diag_type = Full +plt.period = 10 +plt.fields_to_plot = Ex Ey Ez Bx By Bz jx jy jz part_per_cell rho divE + ################################# ######### PULSAR SETUP ########## ################################# pulsar.pulsarType = "dead" # [dead/active]: sets particle injection type pulsar.omega_star = 6245.676 # angular velocity of NS (rad/s) -pulsar.ramp_omega_time = 2e-4 # time over which to ramp up NS angular velocity (s) +pulsar.ramp_omega_time = 0.0 # time over which to ramp up NS angular velocity (s) +#pulsar.ramp_omega_time = 2e-4 # time over which to ramp up NS angular velocity (s) # if ramp_omega_time < 0, omega = omega_star for any t # consistency requires ramp_omega_time = my_constants.to pulsar.center_star = 90000 90000 90000 -pulsar.R_star = 12.e3 # radius of NS (m) +pulsar.R_star = 12032 # radius of NS (m) pulsar.B_star = 8.0323e-6 # magnetic field of NS (T) -pulsar.dR = 1.4e3 +pulsar.dR = 1075 pulsar.verbose = 0 # [0/1]: turn on verbosity for debugging print statements pulsar.EB_external = 1 # [0/1]: to apply external E and B pulsar.E_external_monopole = 1 # [0/1] pulsar.max_ndens = 5.54e6 # max ndens == ndens used in initializing density -pulsar.Ninj_fraction = 0.5 # fraction of sigma injected +pulsar.Ninj_fraction = 0.1 # fraction of sigma injected pulsar.rhoGJ_scale = 1e0 # scaling down of rho_GJ -pulsar.damp_E_internal = 1 # Damp internal electric field +pulsar.damp_E_internal = 0 # Damp internal electric field pulsar.damping_scale = 10.0 # Damping scale factor for internal electric field diff --git a/Source/Particles/Gather/GetExternalFields.cpp b/Source/Particles/Gather/GetExternalFields.cpp index 9bd1be32ea5..e8fbdd6a82b 100644 --- a/Source/Particles/Gather/GetExternalFields.cpp +++ b/Source/Particles/Gather/GetExternalFields.cpp @@ -22,7 +22,7 @@ GetExternalEField::GetExternalEField (const WarpXParIter& a_pti, int a_offset) n m_zfield_partparser = getParser(mypc.m_Ez_particle_parser); } #ifdef PULSAR - else if (PulsarParm::EB_external == 1) + if (PulsarParm::EB_external == 1) { m_type = Pulsar_Efield; m_time = warpx.gett_new(a_pti.GetLevel()); @@ -52,7 +52,7 @@ GetExternalBField::GetExternalBField (const WarpXParIter& a_pti, int a_offset) n m_zfield_partparser = getParser(mypc.m_Bz_particle_parser); } #ifdef PULSAR - else if (PulsarParm::EB_external == 1) + if (PulsarParm::EB_external == 1) { m_type = Pulsar_Bfield; m_time = warpx.gett_new(a_pti.GetLevel()); diff --git a/Source/Particles/PhysicalParticleContainer.cpp b/Source/Particles/PhysicalParticleContainer.cpp index e8afae676f6..65e069eb54f 100644 --- a/Source/Particles/PhysicalParticleContainer.cpp +++ b/Source/Particles/PhysicalParticleContainer.cpp @@ -951,8 +951,8 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) p.id() = -1; continue; } - //if (sigma_inj < 0 and q_pm >0) {p.id()=-1; return;} - //if (sigma_inj > 0 and q_pm <0) {p.id()=-1; return;} + if (sigma_inj < 0 and q_pm >0) {p.id()=-1; continue;} + if (sigma_inj > 0 and q_pm <0) {p.id()=-1; continue;} // if rho is too smal -- we dont inject particles if (std::abs(rho_GJ) < 1E-35) { p.id() = -1; @@ -1130,20 +1130,19 @@ PhysicalParticleContainer::Evolve (int lev, tmp_particle_data[t_lev][index][i].resize(np); } } - -#ifdef AMREX_USE_OMP +#ifdef _OPENMP #pragma omp parallel #endif { -#ifdef AMREX_USE_OMP +#ifdef _OPENMP int thread_num = omp_get_thread_num(); #else int thread_num = 0; #endif - + FArrayBox filtered_Ex, filtered_Ey, filtered_Ez; FArrayBox filtered_Bx, filtered_By, filtered_Bz; - + amrex::Print() << " par iter loop \n" ; for (WarpXParIter pti(*this, lev); pti.isValid(); ++pti) { if (cost && WarpX::load_balance_costs_update_algo == LoadBalanceCostsUpdateAlgo::Timers) @@ -1151,9 +1150,8 @@ PhysicalParticleContainer::Evolve (int lev, amrex::Gpu::synchronize(); } Real wt = amrex::second(); - + const Box& box = pti.validbox(); - auto& attribs = pti.GetAttribs(); auto& wp = attribs[PIdx::w]; @@ -1226,7 +1224,6 @@ PhysicalParticleContainer::Evolve (int lev, const long np_gather = (cEx) ? nfine_gather : np; int e_is_nodal = Ex.is_nodal() and Ey.is_nodal() and Ez.is_nodal(); - // // Gather and push for particles not in the buffer // @@ -1599,7 +1596,6 @@ PhysicalParticleContainer::PushP (int lev, Real dt, box.grow(Ex.nGrowVect()); const long np = pti.numParticles(); - // Data on the grid const FArrayBox& exfab = Ex[pti]; const FArrayBox& eyfab = Ey[pti]; @@ -1946,7 +1942,6 @@ PhysicalParticleContainer::PushPX (WarpXParIter& pti, const auto getPosition = GetParticlePosition(pti, offset); auto setPosition = SetParticlePosition(pti, offset); - const auto getExternalE = GetExternalEField(pti, offset); const auto getExternalB = GetExternalBField(pti, offset); diff --git a/Source/Particles/PulsarParameters.H b/Source/Particles/PulsarParameters.H index 711709cfb71..e2d64917971 100644 --- a/Source/Particles/PulsarParameters.H +++ b/Source/Particles/PulsarParameters.H @@ -9,34 +9,101 @@ namespace PulsarParm { - extern std::string pulsar_type; + extern std::string pulsar_type; + + extern AMREX_GPU_DEVICE_MANAGED amrex::Real omega_star; + extern AMREX_GPU_DEVICE_MANAGED amrex::Real ramp_omega_time; + extern AMREX_GPU_DEVICE_MANAGED amrex::Real B_star; + extern AMREX_GPU_DEVICE_MANAGED amrex::Real R_star; + extern AMREX_GPU_DEVICE_MANAGED amrex::Real dR_star; + extern AMREX_GPU_DEVICE_MANAGED amrex::Real damping_scale; + extern AMREX_GPU_DEVICE_MANAGED int EB_external; + extern AMREX_GPU_DEVICE_MANAGED int E_external_monopole; + extern AMREX_GPU_DEVICE_MANAGED + amrex::GpuArray center_star; + extern AMREX_GPU_DEVICE_MANAGED amrex::Real max_ndens; + extern AMREX_GPU_DEVICE_MANAGED amrex::Real Ninj_fraction; + extern AMREX_GPU_DEVICE_MANAGED amrex::Real rhoGJ_scale; + extern AMREX_GPU_DEVICE_MANAGED int damp_E_internal; + + extern AMREX_GPU_DEVICE_MANAGED int verbose; + + void ReadParameters(); - extern AMREX_GPU_DEVICE_MANAGED amrex::Real omega_star; - extern AMREX_GPU_DEVICE_MANAGED amrex::Real ramp_omega_time; - extern AMREX_GPU_DEVICE_MANAGED amrex::Real B_star; - extern AMREX_GPU_DEVICE_MANAGED amrex::Real R_star; - extern AMREX_GPU_DEVICE_MANAGED amrex::Real dR_star; - extern AMREX_GPU_DEVICE_MANAGED amrex::Real damping_scale; - extern AMREX_GPU_DEVICE_MANAGED int EB_external; - extern AMREX_GPU_DEVICE_MANAGED int E_external_monopole; - extern AMREX_GPU_DEVICE_MANAGED - amrex::GpuArray center_star; - extern AMREX_GPU_DEVICE_MANAGED amrex::Real max_ndens; - extern AMREX_GPU_DEVICE_MANAGED amrex::Real Ninj_fraction; - extern AMREX_GPU_DEVICE_MANAGED amrex::Real rhoGJ_scale; - extern AMREX_GPU_DEVICE_MANAGED int damp_E_internal; - extern AMREX_GPU_DEVICE_MANAGED int verbose; + AMREX_GPU_HOST_DEVICE AMREX_INLINE + amrex::Real Omega(const amrex::Real time) + { + amrex::Real omega = omega_star; + if (ramp_omega_time > 0.0 && time < ramp_omega_time) { + omega = omega_star * time / ramp_omega_time; + } + + return omega; + } - void ReadParameters(); + AMREX_GPU_HOST_DEVICE AMREX_INLINE + void PulsarEField(const amrex::ParticleReal xp, const amrex::ParticleReal yp, + const amrex::ParticleReal zp, + amrex::ParticleReal &Exp, amrex::ParticleReal &Eyp, + amrex::ParticleReal &Ezp, + amrex::Real time) + { + // spherical r, theta, phi + const amrex::Real xc = center_star[0]; + const amrex::Real yc = center_star[1]; + const amrex::Real zc = center_star[2]; + const amrex::Real r = std::sqrt( (xp-xc)*(xp-xc) + (yp-yc)*(yp-yc) + (zp-zc)*(zp-zc) ); + const amrex::Real phi = std::atan2((yp-yc),(xp-xc)); + amrex::Real theta = 0.0; + if (r > 0) { + theta = std::acos((zp-zc)/r); + } + const amrex::Real c_theta = std::cos(theta); + const amrex::Real s_theta = std::sin(theta); + const amrex::Real c_phi = std::cos(phi); + const amrex::Real s_phi = std::sin(phi); + amrex::Real omega = omega_star; + // ramping up omega + if (time < ramp_omega_time) { + omega = omega_star*time/ramp_omega_time; + } + + if (r= R_star ) { + amrex::Real r_ratio = R_star/r; + amrex::Real r3 = r_ratio*r_ratio*r_ratio; + // Taking derivative of phi given in eq 30 of Michel and Li + amrex::Real Er = B_star*omega*R_star*r_ratio*r3*(1.0-3.0*c_theta*c_theta); + if (E_external_monopole == 1) { + Er += (2.0/3.0)*omega*B_star*R_star*r_ratio*r_ratio; + } + amrex::Real Etheta = (-1.0)*B_star*omega*R_star*r_ratio*r3*(2.0*s_theta*c_theta); + + Exp = Er*s_theta*c_phi + Etheta*c_theta*c_phi; + Eyp = Er*s_theta*s_phi + Etheta*c_theta*s_phi; + Ezp = Er*c_theta - Etheta*s_theta; + } + } - AMREX_GPU_HOST_DEVICE AMREX_INLINE - void PulsarEField(const amrex::ParticleReal xp, const amrex::ParticleReal yp, - const amrex::ParticleReal zp, - amrex::ParticleReal &Exp, amrex::ParticleReal &Eyp, - amrex::ParticleReal &Ezp, - amrex::Real time) - { + AMREX_GPU_HOST_DEVICE AMREX_INLINE + void PulsarBField(const amrex::ParticleReal xp, const amrex::ParticleReal yp, + const amrex::ParticleReal zp, + amrex::ParticleReal &Bxp, amrex::ParticleReal &Byp, + amrex::ParticleReal &Bzp, + amrex::Real time) + { // spherical r, theta, phi const amrex::Real xc = center_star[0]; const amrex::Real yc = center_star[1]; @@ -45,100 +112,40 @@ namespace PulsarParm const amrex::Real phi = std::atan2((yp-yc),(xp-xc)); amrex::Real theta = 0.0; if (r > 0) { - theta = std::acos((zp-zc)/r); + theta = std::acos((zp-zc)/r); } const amrex::Real c_theta = std::cos(theta); const amrex::Real s_theta = std::sin(theta); const amrex::Real c_phi = std::cos(phi); const amrex::Real s_phi = std::sin(phi); - amrex::Real omega = omega_star; - // ramping up omega - if (time < 2.0e-4) { - omega = omega_star*time/2.0e-4; - } - - if (r= R_star ) { - amrex::Real r_ratio = R_star/r; - amrex::Real r3 = r_ratio*r_ratio*r_ratio; - // Taking derivative of phi given in eq 30 of Michel and Li - amrex::Real Er = B_star*omega*R_star*r_ratio*r3*(1.0-3.0*c_theta*c_theta); - if (E_external_monopole == 1) { - Er += (2.0/3.0)*omega*B_star*R_star*r_ratio*r_ratio; - } - amrex::Real Etheta = (-1.0)*B_star*omega*R_star*r_ratio*r3*(2.0*s_theta*c_theta); - - Exp = Er*s_theta*c_phi + Etheta*c_theta*c_phi; - Eyp = Er*s_theta*s_phi + Etheta*c_theta*s_phi; - Ezp = Er*c_theta - Etheta*s_theta; - } - } - - - AMREX_GPU_HOST_DEVICE AMREX_INLINE - void PulsarBField(const amrex::ParticleReal xp, const amrex::ParticleReal yp, - const amrex::ParticleReal zp, - amrex::ParticleReal &Bxp, amrex::ParticleReal &Byp, - amrex::ParticleReal &Bzp, - amrex::Real time) - { - // spherical r, theta, phi - const amrex::Real xc = center_star[0]; - const amrex::Real yc = center_star[1]; - const amrex::Real zc = center_star[2]; - const amrex::Real r = std::sqrt( (xp-xc)*(xp-xc) + (yp-yc)*(yp-yc) + (zp-zc)*(zp-zc) ); - const amrex::Real phi = std::atan2((yp-yc),(xp-xc)); - amrex::Real theta = 0.0; - if (r > 0) { - theta = std::acos((zp-zc)/r); - } - const amrex::Real c_theta = std::cos(theta); - const amrex::Real s_theta = std::sin(theta); - const amrex::Real c_phi = std::cos(phi); - const amrex::Real s_phi = std::sin(phi); - amrex::Real omega = omega_star; - // ramping up omega - if (time < 2.0e-4) { - omega = omega_star*time/2.0e-4; - } + amrex::Real omega = Omega(time); if (r= R_star ) { - amrex::Real r_ratio = R_star/r; - amrex::Real r3 = r_ratio*r_ratio*r_ratio; - // Taking derivative of phi given in eq 30 of Michel and Li - amrex::Real Br = 2.0*B_star*r3*c_theta; - amrex::Real Btheta = B_star*r3*s_theta; + amrex::Real r_ratio = R_star/r; + amrex::Real r3 = r_ratio*r_ratio*r_ratio; + // Taking derivative of phi given in eq 30 of Michel and Li + amrex::Real Br = 2.0*B_star*r3*c_theta; + amrex::Real Btheta = B_star*r3*s_theta; - Bxp = Br*s_theta*c_phi + Btheta*c_theta*c_phi; - Byp = Br*s_theta*s_phi + Btheta*c_theta*s_phi; - Bzp = Br*c_theta - Btheta*s_theta; + Bxp = Br*s_theta*c_phi + Btheta*c_theta*c_phi; + Byp = Br*s_theta*s_phi + Btheta*c_theta*s_phi; + Bzp = Br*c_theta - Btheta*s_theta; } - } + } // AMREX_GPU_HOST_DEVICE AMREX_INLINE // void PulsarEBField(amrex::Real xp, amrex::Real yp, amrex::Real zp, @@ -209,8 +216,8 @@ namespace PulsarParm // } // } - namespace Spherical - { + namespace Spherical + { AMREX_GPU_HOST_DEVICE AMREX_INLINE amrex::Real r(int i, int j, int k, amrex::GeometryData const& geom) { @@ -219,47 +226,37 @@ namespace PulsarParm const auto domain_xlo = geom.ProbLo(); const auto domain_xhi = geom.ProbHi(); const auto domain_dx = geom.CellSize(); - + const amrex::Real x = domain_xlo[0] + (i - domain_ilo.x + 0.5) * domain_dx[0]; const amrex::Real y = domain_xlo[1] + (j - domain_ilo.y + 0.5) * domain_dx[1]; const amrex::Real z = domain_xlo[2] + (k - domain_ilo.z + 0.5) * domain_dx[2]; - + const amrex::Real xc = 0.5 * (domain_xlo[0] + domain_xhi[0]); const amrex::Real yc = 0.5 * (domain_xlo[1] + domain_xhi[1]); const amrex::Real zc = 0.5 * (domain_xlo[2] + domain_xhi[2]); - + const amrex::Real r = std::sqrt((x-xc)*(x-xc) + (y-yc)*(y-yc) + (z-zc)*(z-zc)); - + return r; } - } - - AMREX_GPU_HOST_DEVICE AMREX_INLINE - amrex::Real Omega(const amrex::Real time) - { - amrex::Real omega = omega_star; - if (ramp_omega_time > 0.0 && time < ramp_omega_time) { - omega = omega_star * time / ramp_omega_time; - } - - return omega; - } + } - AMREX_GPU_HOST_DEVICE AMREX_INLINE - void DampEField(int i, int j, int k, amrex::GeometryData const& geom, amrex::Array4 const& Efield) - { - const amrex::Real r = Spherical::r(i, j, k, geom); - if (r < R_star) { - // Damping function: Fd = tanh(damping_scale * (r / R_star - 1)) + 1 - // for damping_scale >= 10 or so: - // Fd(0) ~ 0 - // Fd(R_star) ~ 1 - - const amrex::Real Fd = std::tanh(damping_scale * (r / R_star - 1.0)) + 1.0; - Efield(i, j, k) = Efield(i, j, k) * Fd; - } - } + AMREX_GPU_HOST_DEVICE AMREX_INLINE + void DampEField(int i, int j, int k, amrex::GeometryData const& geom, amrex::Array4 const& Efield) + { + const amrex::Real r = Spherical::r(i, j, k, geom); + + if (r < R_star) { + // Damping function: Fd = tanh(damping_scale * (r / R_star - 1)) + 1 + // for damping_scale >= 10 or so: + // Fd(0) ~ 0 + // Fd(R_star) ~ 1 + + const amrex::Real Fd = std::tanh(damping_scale * (r / R_star - 1.0)) + 1.0; + Efield(i, j, k) = Efield(i, j, k) * Fd; + } + } } #endif diff --git a/Source/Particles/PulsarParameters.cpp b/Source/Particles/PulsarParameters.cpp index 0e16a2d0477..65d67f9c9f7 100644 --- a/Source/Particles/PulsarParameters.cpp +++ b/Source/Particles/PulsarParameters.cpp @@ -7,49 +7,50 @@ namespace PulsarParm { - std::string pulsar_type; - - AMREX_GPU_DEVICE_MANAGED amrex::Real omega_star; - AMREX_GPU_DEVICE_MANAGED amrex::Real ramp_omega_time = -1.0; - AMREX_GPU_DEVICE_MANAGED amrex::Real B_star; - AMREX_GPU_DEVICE_MANAGED amrex::Real R_star; - AMREX_GPU_DEVICE_MANAGED amrex::Real dR_star; - AMREX_GPU_DEVICE_MANAGED amrex::Real damping_scale = 10.0; - AMREX_GPU_DEVICE_MANAGED int EB_external = 0; - AMREX_GPU_DEVICE_MANAGED int E_external_monopole = 0; - AMREX_GPU_DEVICE_MANAGED - amrex::GpuArray center_star; - AMREX_GPU_DEVICE_MANAGED int damp_E_internal = 0; - AMREX_GPU_DEVICE_MANAGED int verbose = 0; - AMREX_GPU_DEVICE_MANAGED amrex::Real max_ndens; - AMREX_GPU_DEVICE_MANAGED amrex::Real Ninj_fraction; - AMREX_GPU_DEVICE_MANAGED amrex::Real rhoGJ_scale; - - void ReadParameters() { - amrex::ParmParse pp("pulsar"); - pp.query("pulsarType",pulsar_type); - pp.query("omega_star",omega_star); - amrex::Vector center_star_v(AMREX_SPACEDIM); - pp.queryarr("center_star",center_star_v); - std::copy(center_star_v.begin(),center_star_v.end(),center_star.begin()); - pp.query("R_star",R_star); - pp.query("B_star",B_star); - pp.query("dR",dR_star); - pp.query("verbose",verbose); - pp.query("EB_external",EB_external); - pp.query("E_external_monopole",E_external_monopole); - pp.query("damp_E_internal",damp_E_internal); - pp.query("damping_scale",damping_scale); - pp.query("ramp_omega_time",ramp_omega_time); - amrex::Print() << " Pulsar center: " << center_star[0] << " " << center_star[1] << " " << center_star[2] << "\n"; - amrex::Print() << " Pulsar omega: " << omega_star << "\n"; - amrex::Print() << " Pulsar B_star : " << B_star << "\n"; - pp.get("max_ndens", max_ndens); - pp.get("Ninj_fraction",Ninj_fraction); - pp.get("rhoGJ_scale",rhoGJ_scale); - amrex::Print() << " pulsar max ndens " << max_ndens << "\n"; - amrex::Print() << " pulsar ninj fraction " << Ninj_fraction << "\n"; - amrex::Print() << " pulsar rhoGJ scaling " << rhoGJ_scale << "\n"; - } + std::string pulsar_type; + + AMREX_GPU_DEVICE_MANAGED amrex::Real omega_star; + AMREX_GPU_DEVICE_MANAGED amrex::Real ramp_omega_time = -1.0; + AMREX_GPU_DEVICE_MANAGED amrex::Real B_star; + AMREX_GPU_DEVICE_MANAGED amrex::Real R_star; + AMREX_GPU_DEVICE_MANAGED amrex::Real dR_star; + AMREX_GPU_DEVICE_MANAGED amrex::Real damping_scale = 10.0; + AMREX_GPU_DEVICE_MANAGED int EB_external = 0; + AMREX_GPU_DEVICE_MANAGED int E_external_monopole = 0; + AMREX_GPU_DEVICE_MANAGED + amrex::GpuArray center_star; + AMREX_GPU_DEVICE_MANAGED int damp_E_internal = 0; + AMREX_GPU_DEVICE_MANAGED int verbose = 0; + AMREX_GPU_DEVICE_MANAGED amrex::Real max_ndens; + AMREX_GPU_DEVICE_MANAGED amrex::Real Ninj_fraction; + AMREX_GPU_DEVICE_MANAGED amrex::Real rhoGJ_scale; + + void ReadParameters() { + amrex::ParmParse pp("pulsar"); + pp.query("pulsarType",pulsar_type); + pp.get("omega_star",omega_star); + amrex::Vector center_star_v(AMREX_SPACEDIM); + pp.getarr("center_star",center_star_v); + std::copy(center_star_v.begin(),center_star_v.end(),center_star.begin()); + pp.get("R_star",R_star); + pp.get("B_star",B_star); + pp.get("dR",dR_star); + pp.query("verbose",verbose); + pp.query("EB_external",EB_external); + pp.query("E_external_monopole",E_external_monopole); + pp.query("damp_E_internal",damp_E_internal); + pp.query("damping_scale",damping_scale); + pp.query("ramp_omega_time",ramp_omega_time); + amrex::Print() << " Pulsar center: " << center_star[0] << " " << center_star[1] << " " << center_star[2] << "\n"; + amrex::Print() << " Pulsar omega: " << omega_star << "\n"; + amrex::Print() << " Pulsar B_star : " << B_star << "\n"; + pp.get("max_ndens", max_ndens); + pp.get("Ninj_fraction",Ninj_fraction); + pp.get("rhoGJ_scale",rhoGJ_scale); + amrex::Print() << " pulsar max ndens " << max_ndens << "\n"; + amrex::Print() << " pulsar ninj fraction " << Ninj_fraction << "\n"; + amrex::Print() << " pulsar rhoGJ scaling " << rhoGJ_scale << "\n"; + amrex::Print() << " EB_external : " << EB_external << "\n"; + } } From 54ea2ebdbb563de796a1a1481763811ca05050b5 Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Thu, 9 Jul 2020 11:10:57 -0700 Subject: [PATCH 051/120] include staggering --- Source/Particles/PulsarParameters.H | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/Source/Particles/PulsarParameters.H b/Source/Particles/PulsarParameters.H index e2d64917971..0f930fcd5a8 100644 --- a/Source/Particles/PulsarParameters.H +++ b/Source/Particles/PulsarParameters.H @@ -219,7 +219,7 @@ namespace PulsarParm namespace Spherical { AMREX_GPU_HOST_DEVICE AMREX_INLINE - amrex::Real r(int i, int j, int k, amrex::GeometryData const& geom) + amrex::Real r(int i, int j, int k, amrex::GeometryData const& geom, const amrex::IntVect mf_ixType) { const auto domain_box = geom.Domain(); const auto domain_ilo = amrex::lbound(domain_box); @@ -227,9 +227,12 @@ namespace PulsarParm const auto domain_xhi = geom.ProbHi(); const auto domain_dx = geom.CellSize(); - const amrex::Real x = domain_xlo[0] + (i - domain_ilo.x + 0.5) * domain_dx[0]; - const amrex::Real y = domain_xlo[1] + (j - domain_ilo.y + 0.5) * domain_dx[1]; - const amrex::Real z = domain_xlo[2] + (k - domain_ilo.z + 0.5) * domain_dx[2]; + //const amrex::Real x = domain_xlo[0] + (i - domain_ilo.x + 0.5) * domain_dx[0] + (1.0 - mf_ixType[0])*domain_dx[0]*0.5; + //const amrex::Real y = domain_xlo[1] + (j - domain_ilo.y + 0.5) * domain_dx[1] + (1.0 - mf_ixType[1])*domain_dx[1]*0.5; + //const amrex::Real z = domain_xlo[2] + (k - domain_ilo.z + 0.5) * domain_dx[2] + (1.0 - mf_ixType[2])*domain_dx[2]*0.5; + const amrex::Real x = domain_xlo[0] + (i ) * domain_dx[0] + (1.0 - mf_ixType[0])*domain_dx[0]*0.5; + const amrex::Real y = domain_xlo[1] + (j ) * domain_dx[1] + (1.0 - mf_ixType[1])*domain_dx[1]*0.5; + const amrex::Real z = domain_xlo[2] + (k ) * domain_dx[2] + (1.0 - mf_ixType[2])*domain_dx[2]*0.5; const amrex::Real xc = 0.5 * (domain_xlo[0] + domain_xhi[0]); const amrex::Real yc = 0.5 * (domain_xlo[1] + domain_xhi[1]); @@ -243,9 +246,9 @@ namespace PulsarParm AMREX_GPU_HOST_DEVICE AMREX_INLINE - void DampEField(int i, int j, int k, amrex::GeometryData const& geom, amrex::Array4 const& Efield) + void DampEField(int i, int j, int k, amrex::GeometryData const& geom, amrex::Array4 const& Efield, const amrex::IntVect mf_ixtype) { - const amrex::Real r = Spherical::r(i, j, k, geom); + const amrex::Real r = Spherical::r(i, j, k, geom, mf_ixType); if (r < R_star) { // Damping function: Fd = tanh(damping_scale * (r / R_star - 1)) + 1 From 004d898bff077d4383790ca183d55ec119747c88 Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Thu, 9 Jul 2020 13:39:32 -0700 Subject: [PATCH 052/120] damp b field and include staggering. fix compilation errors --- .../pulsar/inputs.corotating.3d.PM | 4 +- Source/Evolve/WarpXEvolve.cpp | 64 +++++++++++++++++-- .../Particles/PhysicalParticleContainer.cpp | 1 - Source/Particles/PulsarParameters.H | 8 +-- Source/Particles/PulsarParameters.cpp | 4 +- 5 files changed, 67 insertions(+), 14 deletions(-) diff --git a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM index fd1befef30a..59d07afe6c2 100644 --- a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM +++ b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM @@ -146,9 +146,9 @@ pulsar.B_star = 8.0323e-6 # magnetic field of NS (T) pulsar.dR = 1075 pulsar.verbose = 0 # [0/1]: turn on verbosity for debugging print statements pulsar.EB_external = 1 # [0/1]: to apply external E and B -pulsar.E_external_monopole = 1 # [0/1] +pulsar.E_external_monopole = 0 # [0/1] pulsar.max_ndens = 5.54e6 # max ndens == ndens used in initializing density pulsar.Ninj_fraction = 0.1 # fraction of sigma injected pulsar.rhoGJ_scale = 1e0 # scaling down of rho_GJ -pulsar.damp_E_internal = 0 # Damp internal electric field +pulsar.damp_EB_internal = 1 # Damp internal electric field pulsar.damping_scale = 10.0 # Damping scale factor for internal electric field diff --git a/Source/Evolve/WarpXEvolve.cpp b/Source/Evolve/WarpXEvolve.cpp index 49b2e02ded1..009b05bbe44 100644 --- a/Source/Evolve/WarpXEvolve.cpp +++ b/Source/Evolve/WarpXEvolve.cpp @@ -172,13 +172,43 @@ WarpX::Evolve (int numsteps) } #ifdef PULSAR - if (PulsarParm::damp_E_internal) { + if (PulsarParm::damp_EB_internal) { MultiFab *Ex, *Ey, *Ez; + MultiFab *Bx, *By, *Bz; for (int lev = 0; lev <= finest_level; ++lev) { Ex = Efield_fp[lev][0].get(); Ey = Efield_fp[lev][1].get(); Ez = Efield_fp[lev][2].get(); - + Bx = Bfield_fp[lev][0].get(); + By = Bfield_fp[lev][1].get(); + Bz = Bfield_fp[lev][2].get(); + Gpu::ManagedVector Ex_stag, Ey_stag, Ez_stag, Bx_stag, By_stag, Bz_stag; + Ex_stag.resize(3); + Ey_stag.resize(3); + Ez_stag.resize(3); + Bx_stag.resize(3); + By_stag.resize(3); + Bz_stag.resize(3); + amrex::IntVect ex_type = Ex->ixType().toIntVect(); + amrex::IntVect ey_type = Ey->ixType().toIntVect(); + amrex::IntVect ez_type = Ez->ixType().toIntVect(); + amrex::IntVect bx_type = Bx->ixType().toIntVect(); + amrex::IntVect by_type = By->ixType().toIntVect(); + amrex::IntVect bz_type = Bz->ixType().toIntVect(); + for (int idim = 0; idim < AMREX_SPACEDIM-1; ++idim) { + Ex_stag[idim] = ex_type[idim]; + Ey_stag[idim] = ey_type[idim]; + Ez_stag[idim] = ez_type[idim]; + Bx_stag[idim] = bx_type[idim]; + By_stag[idim] = by_type[idim]; + Bz_stag[idim] = bz_type[idim]; + } + int const* const AMREX_RESTRICT Ex_stag_ptr = Ex_stag.data(); + int const* const AMREX_RESTRICT Ey_stag_ptr = Ey_stag.data(); + int const* const AMREX_RESTRICT Ez_stag_ptr = Ez_stag.data(); + int const* const AMREX_RESTRICT Bx_stag_ptr = Bx_stag.data(); + int const* const AMREX_RESTRICT By_stag_ptr = By_stag.data(); + int const* const AMREX_RESTRICT Bz_stag_ptr = Bz_stag.data(); auto geom = Geom(lev).data(); #ifdef _OPENMP #pragma omp parallel if (Gpu::notInLaunchRegion()) @@ -196,15 +226,39 @@ WarpX::Evolve (int numsteps) amrex::ParallelFor(tex, tey, tez, [=] AMREX_GPU_DEVICE (int i, int j, int k) { - PulsarParm::DampEField(i, j, k, geom, Exfab); + PulsarParm::DampEField(i, j, k, geom, Exfab, Ex_stag_ptr); + }, + [=] AMREX_GPU_DEVICE (int i, int j, int k) + { + PulsarParm::DampEField(i, j, k, geom, Eyfab, Ey_stag_ptr); + }, + [=] AMREX_GPU_DEVICE (int i, int j, int k) + { + PulsarParm::DampEField(i, j, k, geom, Ezfab, Ez_stag_ptr); + }); + } + for ( MFIter mfi(*Bx, TilingIfNotGPU()); mfi.isValid(); ++mfi ) + { + const Box& tex = mfi.tilebox( Bx->ixType().toIntVect() ); + const Box& tey = mfi.tilebox( By->ixType().toIntVect() ); + const Box& tez = mfi.tilebox( Bz->ixType().toIntVect() ); + + auto const& Bxfab = Bx->array(mfi); + auto const& Byfab = By->array(mfi); + auto const& Bzfab = Bz->array(mfi); + + amrex::ParallelFor(tex, tey, tez, + [=] AMREX_GPU_DEVICE (int i, int j, int k) + { + PulsarParm::DampEField(i, j, k, geom, Bxfab, Bx_stag_ptr); }, [=] AMREX_GPU_DEVICE (int i, int j, int k) { - PulsarParm::DampEField(i, j, k, geom, Eyfab); + PulsarParm::DampEField(i, j, k, geom, Byfab, By_stag_ptr); }, [=] AMREX_GPU_DEVICE (int i, int j, int k) { - PulsarParm::DampEField(i, j, k, geom, Ezfab); + PulsarParm::DampEField(i, j, k, geom, Bzfab, Bz_stag_ptr); }); } } diff --git a/Source/Particles/PhysicalParticleContainer.cpp b/Source/Particles/PhysicalParticleContainer.cpp index 65e069eb54f..a89cdbc17e5 100644 --- a/Source/Particles/PhysicalParticleContainer.cpp +++ b/Source/Particles/PhysicalParticleContainer.cpp @@ -1142,7 +1142,6 @@ PhysicalParticleContainer::Evolve (int lev, FArrayBox filtered_Ex, filtered_Ey, filtered_Ez; FArrayBox filtered_Bx, filtered_By, filtered_Bz; - amrex::Print() << " par iter loop \n" ; for (WarpXParIter pti(*this, lev); pti.isValid(); ++pti) { if (cost && WarpX::load_balance_costs_update_algo == LoadBalanceCostsUpdateAlgo::Timers) diff --git a/Source/Particles/PulsarParameters.H b/Source/Particles/PulsarParameters.H index 0f930fcd5a8..5ea19786570 100644 --- a/Source/Particles/PulsarParameters.H +++ b/Source/Particles/PulsarParameters.H @@ -24,7 +24,7 @@ namespace PulsarParm extern AMREX_GPU_DEVICE_MANAGED amrex::Real max_ndens; extern AMREX_GPU_DEVICE_MANAGED amrex::Real Ninj_fraction; extern AMREX_GPU_DEVICE_MANAGED amrex::Real rhoGJ_scale; - extern AMREX_GPU_DEVICE_MANAGED int damp_E_internal; + extern AMREX_GPU_DEVICE_MANAGED int damp_EB_internal; extern AMREX_GPU_DEVICE_MANAGED int verbose; @@ -219,7 +219,7 @@ namespace PulsarParm namespace Spherical { AMREX_GPU_HOST_DEVICE AMREX_INLINE - amrex::Real r(int i, int j, int k, amrex::GeometryData const& geom, const amrex::IntVect mf_ixType) + amrex::Real r(int i, int j, int k, amrex::GeometryData const& geom, int const* const AMREX_RESTRICT mf_ixType) { const auto domain_box = geom.Domain(); const auto domain_ilo = amrex::lbound(domain_box); @@ -246,9 +246,9 @@ namespace PulsarParm AMREX_GPU_HOST_DEVICE AMREX_INLINE - void DampEField(int i, int j, int k, amrex::GeometryData const& geom, amrex::Array4 const& Efield, const amrex::IntVect mf_ixtype) + void DampEField(int i, int j, int k, amrex::GeometryData const& geom, amrex::Array4 const& Efield, int const* const AMREX_RESTRICT mf_ixtype) { - const amrex::Real r = Spherical::r(i, j, k, geom, mf_ixType); + const amrex::Real r = Spherical::r(i, j, k, geom, mf_ixtype); if (r < R_star) { // Damping function: Fd = tanh(damping_scale * (r / R_star - 1)) + 1 diff --git a/Source/Particles/PulsarParameters.cpp b/Source/Particles/PulsarParameters.cpp index 65d67f9c9f7..bb9f2142652 100644 --- a/Source/Particles/PulsarParameters.cpp +++ b/Source/Particles/PulsarParameters.cpp @@ -19,7 +19,7 @@ namespace PulsarParm AMREX_GPU_DEVICE_MANAGED int E_external_monopole = 0; AMREX_GPU_DEVICE_MANAGED amrex::GpuArray center_star; - AMREX_GPU_DEVICE_MANAGED int damp_E_internal = 0; + AMREX_GPU_DEVICE_MANAGED int damp_EB_internal = 0; AMREX_GPU_DEVICE_MANAGED int verbose = 0; AMREX_GPU_DEVICE_MANAGED amrex::Real max_ndens; AMREX_GPU_DEVICE_MANAGED amrex::Real Ninj_fraction; @@ -38,7 +38,7 @@ namespace PulsarParm pp.query("verbose",verbose); pp.query("EB_external",EB_external); pp.query("E_external_monopole",E_external_monopole); - pp.query("damp_E_internal",damp_E_internal); + pp.query("damp_EB_internal",damp_EB_internal); pp.query("damping_scale",damping_scale); pp.query("ramp_omega_time",ramp_omega_time); amrex::Print() << " Pulsar center: " << center_star[0] << " " << center_star[1] << " " << center_star[2] << "\n"; From 33bc56064647fe94c50ddf38ef11a93fb7522bda Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Thu, 23 Jul 2020 12:22:23 -0700 Subject: [PATCH 053/120] fixed Ecell --- .../Particles/PhysicalParticleContainer.cpp | 32 +++++++++++-------- 1 file changed, 18 insertions(+), 14 deletions(-) diff --git a/Source/Particles/PhysicalParticleContainer.cpp b/Source/Particles/PhysicalParticleContainer.cpp index a89cdbc17e5..6e85b3a36ed 100644 --- a/Source/Particles/PhysicalParticleContainer.cpp +++ b/Source/Particles/PhysicalParticleContainer.cpp @@ -822,7 +822,7 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) amrex::ParallelForRNG(overlap_box, [=] AMREX_GPU_DEVICE (int i, int j, int k, amrex::RandomEngine const& engine) noexcept { - IntVect iv = IntVect(AMREX_D_DECL(i, j, k)); + amrex::IntVect iv = amrex::IntVect(AMREX_D_DECL(i, j, k)); const auto index = overlap_box.index(iv); for (int i_part = 0; i_part < pcounts[index]; ++i_part) { @@ -919,23 +919,26 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) amrex::Real Er_cor = PulsarParm::B_star *omega *cc_rad*s_theta*s_theta; - Real Er_ext = omega*PulsarParm::B_star*cc_rad*(1.0-3.0*c_theta*c_theta); - Er_ext += (2.0/3.0)*omega*PulsarParm::B_star*cc_rad; + //// Er_external is known + //Real Er_ext = omega*PulsarParm::B_star*cc_rad*(1.0-3.0*c_theta*c_theta); + //Er_ext += (2.0/3.0)*omega*PulsarParm::B_star*cc_rad; + //// rho_GJ is known amrex::Real rho_GJ = 2*PhysConst::ep0*PulsarParm::B_star*omega* (1.0-3.0*c_theta*c_theta)*PulsarParm::rhoGJ_scale; int ii = Ex_lo.x + iv[0]; int jj = Ex_lo.y + iv[1]; int kk = Ex_lo.z + iv[2]; Real ex_avg = 0.25*(ex_arr(ii,jj,kk) + ex_arr(ii,jj+1,kk)+ex_arr(ii,jj,kk+1) + ex_arr(ii,jj+1,kk+1)); - Real ey_avg = 0.25*(ex_arr(ii,jj,kk) + ex_arr(ii+1,jj,kk)+ex_arr(ii,jj,kk+1) + ex_arr(ii+1,jj,kk+1)); - Real ez_avg = 0.25*(ex_arr(ii,jj,kk) + ex_arr(ii,jj+1,kk)+ex_arr(ii+1,jj,kk) + ex_arr(ii+1,jj+1,kk)); + Real ey_avg = 0.25*(ey_arr(ii,jj,kk) + ey_arr(ii+1,jj,kk)+ey_arr(ii,jj,kk+1) + ey_arr(ii+1,jj,kk+1)); + Real ez_avg = 0.25*(ez_arr(ii,jj,kk) + ez_arr(ii,jj+1,kk)+ez_arr(ii+1,jj,kk) + ez_arr(ii+1,jj+1,kk)); Real Er_cell = ex_avg*s_theta*c_phi + ey_avg*s_theta*s_phi + ez_avg*c_theta; // analytical surface charge density - Real sigma_inj = (( Er_ext - Er_cor)); + //Real sigma_inj = (( Er_ext - Er_cor)); + Real sigma_inj = (( Er_cell - Er_cor)); Real max_dens = PulsarParm::max_ndens; amrex::Real fraction = PulsarParm::Ninj_fraction; // number of particle pairs injected - Real N_inj = fraction*std::abs(sigma_inj) *PhysConst::ep0* dx[0]*dx[0]/(PhysConst::q_e*max_dens*scale_fac); + Real N_inj = fraction*amrex::Math::abs(sigma_inj) *PhysConst::ep0* dx[0]*dx[0]/(PhysConst::q_e*max_dens*scale_fac); if (t > 0) { if (N_inj >= 1) { if (N_inj < num_ppc) { @@ -951,18 +954,19 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) p.id() = -1; continue; } - if (sigma_inj < 0 and q_pm >0) {p.id()=-1; continue;} - if (sigma_inj > 0 and q_pm <0) {p.id()=-1; continue;} + //if (sigma_inj < 0 and q_pm >0) {p.id()=-1; continue;} + //if (sigma_inj > 0 and q_pm <0) {p.id()=-1; continue;} + //if (sigma_inj < 0 and q_pm >0) {p.id()=-1; continue;} + //if (sigma_inj > 0 and q_pm <0) {p.id()=-1; continue;} // if rho is too smal -- we dont inject particles - if (std::abs(rho_GJ) < 1E-35) { + if (std::abs(rho_GJ) < 1.0E-20) { p.id() = -1; continue; } else { - if (std::abs(rho_arr(ii,jj,kk)) > 0) { - Real rel_rho_err = std::abs((rho_arr(ii,jj,kk) - rho_GJ)/rho_GJ); - //amrex::Print() << " rho is " << rho_arr(ii,jj,kk) << " rho_GJ " << rho_GJ << " rel err : " << rel_rho_err << "\n"; - if ( rel_rho_err < 0.05) { + Real rel_rho_err = ((rho_arr(ii,jj,kk) - rho_GJ)/rho_GJ); + // If current rho is much higher than rho_GJ, particles are not introduced. + if ( amrex::Math::abs(rel_rho_err) > 0.05) { p.id() = -1; continue; } From f978cf648e6a90ea4382561c4c7eded2052b51f7 Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Thu, 23 Jul 2020 13:02:55 -0700 Subject: [PATCH 054/120] removing particles if inside R_Star --- Source/Initialization/InjectorPosition.H | 4 ++-- Source/Particles/PhysicalParticleContainer.cpp | 7 ++++--- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/Source/Initialization/InjectorPosition.H b/Source/Initialization/InjectorPosition.H index 502f0311567..6d83c397884 100644 --- a/Source/Initialization/InjectorPosition.H +++ b/Source/Initialization/InjectorPosition.H @@ -139,8 +139,8 @@ struct InjectorPosition bool insidePulsarBounds (amrex::Real r, amrex::Real R_star, amrex::Real dR_star) const noexcept { - // return (r>=R_star and r<=(R_star+dR_star)); - return (r<=R_star and r>=(R_star-dR_star)); + //return (r<=R_star and r>=(R_star-dR_star)); + return (r<=(R_star+dR_star) and r>=(R_star-dR_star)); } #endif diff --git a/Source/Particles/PhysicalParticleContainer.cpp b/Source/Particles/PhysicalParticleContainer.cpp index 6e85b3a36ed..016f25f4bd6 100644 --- a/Source/Particles/PhysicalParticleContainer.cpp +++ b/Source/Particles/PhysicalParticleContainer.cpp @@ -956,8 +956,8 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) } //if (sigma_inj < 0 and q_pm >0) {p.id()=-1; continue;} //if (sigma_inj > 0 and q_pm <0) {p.id()=-1; continue;} - //if (sigma_inj < 0 and q_pm >0) {p.id()=-1; continue;} - //if (sigma_inj > 0 and q_pm <0) {p.id()=-1; continue;} + if (sigma_inj < 0 and q_pm >0) {p.id()=-1; continue;} + if (sigma_inj > 0 and q_pm <0) {p.id()=-1; continue;} // if rho is too smal -- we dont inject particles if (std::abs(rho_GJ) < 1.0E-20) { p.id() = -1; @@ -2257,7 +2257,8 @@ void PhysicalParticleContainer::PulsarParticleRemoval() { Real r = std::sqrt((x-xc)*(x-xc) + (y-yc)*(y-yc) + (z-zc)*(z-zc)); - if (r<=(PulsarParm::R_star-PulsarParm::dR_star)) { + //if (r<=(PulsarParm::R_star-PulsarParm::dR_star)) { + if (r<=(PulsarParm::R_star)) { pp[i].id() = -1; } }); From 0896e14d6bee4fbc03a6a396d46b24dedf097845 Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Thu, 23 Jul 2020 15:19:57 -0700 Subject: [PATCH 055/120] recent input file --- .../pulsar/inputs.corotating.3d.PM | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM index 59d07afe6c2..4785f42cc0c 100644 --- a/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM +++ b/Examples/Physics_applications/pulsar/inputs.corotating.3d.PM @@ -13,8 +13,7 @@ ################################# ####### GENERAL PARAMETERS ###### ################################# -max_step = 100 -#amr.n_cell = 256 256 256 +max_step = 50000 amr.n_cell = 128 128 128 amr.max_grid_size = 64 amr.blocking_factor = 64 @@ -66,7 +65,7 @@ plasma_e.charge = -q_e plasma_e.mass = m_e plasma_e.injection_style = "NUniformPerCell" plasma_e.profile = parse_density_function -plasma_e.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star) * ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=(r_star-dR)) )*dens" +plasma_e.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=(r_star+dR)) * ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=(r_star)) )*dens" plasma_e.num_particles_per_cell_each_dim = 3 3 3 plasma_e.momentum_distribution_type = parse_momentum_function @@ -98,7 +97,7 @@ plasma_p.mass = m_e plasma_p.injection_style = "NUniformPerCell" plasma_p.profile = parse_density_function #plasma_p.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=r_star)* ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<(r_star+dR)))*dens" -plasma_p.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=r_star) * ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=(r_star-dR)) )*dens" +plasma_p.density_function(x,y,z) = "( ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))<=(r_star+dR)) * ((( (z-zc)*(z-zc) + (y-yc)*(y-yc) + (x-xc)*(x-xc) )^(0.5))>=(r_star)) )*dens" plasma_p.num_particles_per_cell_each_dim = 3 3 3 plasma_p.momentum_distribution_type = parse_momentum_function @@ -127,7 +126,7 @@ plasma_p.density_min = 1E0 diagnostics.diags_names = plt plt.diag_type = Full -plt.period = 10 +plt.period = 200 plt.fields_to_plot = Ex Ey Ez Bx By Bz jx jy jz part_per_cell rho divE @@ -136,8 +135,12 @@ plt.fields_to_plot = Ex Ey Ez Bx By Bz jx jy jz part_per_cell rho divE ################################# pulsar.pulsarType = "dead" # [dead/active]: sets particle injection type pulsar.omega_star = 6245.676 # angular velocity of NS (rad/s) +<<<<<<< HEAD pulsar.ramp_omega_time = 0.0 # time over which to ramp up NS angular velocity (s) #pulsar.ramp_omega_time = 2e-4 # time over which to ramp up NS angular velocity (s) +======= +pulsar.ramp_omega_time = 0.e-5 # time over which to ramp up NS angular velocity (s) +>>>>>>> 2756eb86 (recent input file) # if ramp_omega_time < 0, omega = omega_star for any t # consistency requires ramp_omega_time = my_constants.to pulsar.center_star = 90000 90000 90000 From 2ec33420401077046b7443858b1a2a0bccb24c62 Mon Sep 17 00:00:00 2001 From: RevathiJambunathan Date: Thu, 23 Jul 2020 15:22:36 -0700 Subject: [PATCH 056/120] eol fix --- Source/Particles/Gather/GetExternalFields.H | 4 +-- .../Particles/PhysicalParticleContainer.cpp | 6 ++--- Source/Particles/PulsarParameters.H | 26 +++++++++---------- Source/Particles/PulsarParameters.cpp | 4 +-- 4 files changed, 20 insertions(+), 20 deletions(-) diff --git a/Source/Particles/Gather/GetExternalFields.H b/Source/Particles/Gather/GetExternalFields.H index de2cec09b38..91f868b8942 100644 --- a/Source/Particles/Gather/GetExternalFields.H +++ b/Source/Particles/Gather/GetExternalFields.H @@ -57,13 +57,13 @@ struct GetExternalField { amrex::ParticleReal x, y, z; m_get_position(i, x, y, z); - PulsarParm::PulsarEField(x, y, z, field_x, field_y, field_z, m_time); + PulsarParm::PulsarEField(x, y, z, field_x, field_y, field_z, m_time); } else if (m_type == Pulsar_Bfield) { amrex::ParticleReal x, y, z; m_get_position(i, x, y, z); - PulsarParm::PulsarBField(x, y, z, field_x, field_y, field_z, m_time); + PulsarParm::PulsarBField(x, y, z, field_x, field_y, field_z, m_time); } #endif else diff --git a/Source/Particles/PhysicalParticleContainer.cpp b/Source/Particles/PhysicalParticleContainer.cpp index 016f25f4bd6..993f1021f3d 100644 --- a/Source/Particles/PhysicalParticleContainer.cpp +++ b/Source/Particles/PhysicalParticleContainer.cpp @@ -822,7 +822,7 @@ PhysicalParticleContainer::AddPlasma (int lev, RealBox part_realbox) amrex::ParallelForRNG(overlap_box, [=] AMREX_GPU_DEVICE (int i, int j, int k, amrex::RandomEngine const& engine) noexcept { - amrex::IntVect iv = amrex::IntVect(AMREX_D_DECL(i, j, k)); + amrex::IntVect iv = amrex::IntVect(AMREX_D_DECL(i, j, k)); const auto index = overlap_box.index(iv); for (int i_part = 0; i_part < pcounts[index]; ++i_part) { @@ -1143,7 +1143,7 @@ PhysicalParticleContainer::Evolve (int lev, #else int thread_num = 0; #endif - + FArrayBox filtered_Ex, filtered_Ey, filtered_Ez; FArrayBox filtered_Bx, filtered_By, filtered_Bz; for (WarpXParIter pti(*this, lev); pti.isValid(); ++pti) @@ -1153,7 +1153,7 @@ PhysicalParticleContainer::Evolve (int lev, amrex::Gpu::synchronize(); } Real wt = amrex::second(); - + const Box& box = pti.validbox(); auto& attribs = pti.GetAttribs(); diff --git a/Source/Particles/PulsarParameters.H b/Source/Particles/PulsarParameters.H index 5ea19786570..185411e41e6 100644 --- a/Source/Particles/PulsarParameters.H +++ b/Source/Particles/PulsarParameters.H @@ -10,7 +10,7 @@ namespace PulsarParm { extern std::string pulsar_type; - + extern AMREX_GPU_DEVICE_MANAGED amrex::Real omega_star; extern AMREX_GPU_DEVICE_MANAGED amrex::Real ramp_omega_time; extern AMREX_GPU_DEVICE_MANAGED amrex::Real B_star; @@ -25,9 +25,9 @@ namespace PulsarParm extern AMREX_GPU_DEVICE_MANAGED amrex::Real Ninj_fraction; extern AMREX_GPU_DEVICE_MANAGED amrex::Real rhoGJ_scale; extern AMREX_GPU_DEVICE_MANAGED int damp_EB_internal; - + extern AMREX_GPU_DEVICE_MANAGED int verbose; - + void ReadParameters(); @@ -38,7 +38,7 @@ namespace PulsarParm if (ramp_omega_time > 0.0 && time < ramp_omega_time) { omega = omega_star * time / ramp_omega_time; } - + return omega; } @@ -68,7 +68,7 @@ namespace PulsarParm if (time < ramp_omega_time) { omega = omega_star*time/ramp_omega_time; } - + if (r= R_star ) { amrex::Real r_ratio = R_star/r; @@ -90,7 +90,7 @@ namespace PulsarParm Er += (2.0/3.0)*omega*B_star*R_star*r_ratio*r_ratio; } amrex::Real Etheta = (-1.0)*B_star*omega*R_star*r_ratio*r3*(2.0*s_theta*c_theta); - + Exp = Er*s_theta*c_phi + Etheta*c_theta*c_phi; Eyp = Er*s_theta*s_phi + Etheta*c_theta*s_phi; Ezp = Er*c_theta - Etheta*s_theta; @@ -226,20 +226,20 @@ namespace PulsarParm const auto domain_xlo = geom.ProbLo(); const auto domain_xhi = geom.ProbHi(); const auto domain_dx = geom.CellSize(); - + //const amrex::Real x = domain_xlo[0] + (i - domain_ilo.x + 0.5) * domain_dx[0] + (1.0 - mf_ixType[0])*domain_dx[0]*0.5; //const amrex::Real y = domain_xlo[1] + (j - domain_ilo.y + 0.5) * domain_dx[1] + (1.0 - mf_ixType[1])*domain_dx[1]*0.5; //const amrex::Real z = domain_xlo[2] + (k - domain_ilo.z + 0.5) * domain_dx[2] + (1.0 - mf_ixType[2])*domain_dx[2]*0.5; const amrex::Real x = domain_xlo[0] + (i ) * domain_dx[0] + (1.0 - mf_ixType[0])*domain_dx[0]*0.5; const amrex::Real y = domain_xlo[1] + (j ) * domain_dx[1] + (1.0 - mf_ixType[1])*domain_dx[1]*0.5; const amrex::Real z = domain_xlo[2] + (k ) * domain_dx[2] + (1.0 - mf_ixType[2])*domain_dx[2]*0.5; - + const amrex::Real xc = 0.5 * (domain_xlo[0] + domain_xhi[0]); const amrex::Real yc = 0.5 * (domain_xlo[1] + domain_xhi[1]); const amrex::Real zc = 0.5 * (domain_xlo[2] + domain_xhi[2]); - + const amrex::Real r = std::sqrt((x-xc)*(x-xc) + (y-yc)*(y-yc) + (z-zc)*(z-zc)); - + return r; } } @@ -249,13 +249,13 @@ namespace PulsarParm void DampEField(int i, int j, int k, amrex::GeometryData const& geom, amrex::Array4 const& Efield, int const* const AMREX_RESTRICT mf_ixtype) { const amrex::Real r = Spherical::r(i, j, k, geom, mf_ixtype); - + if (r < R_star) { // Damping function: Fd = tanh(damping_scale * (r / R_star - 1)) + 1 // for damping_scale >= 10 or so: // Fd(0) ~ 0 // Fd(R_star) ~ 1 - + const amrex::Real Fd = std::tanh(damping_scale * (r / R_star - 1.0)) + 1.0; Efield(i, j, k) = Efield(i, j, k) * Fd; } diff --git a/Source/Particles/PulsarParameters.cpp b/Source/Particles/PulsarParameters.cpp index bb9f2142652..85d08be6662 100644 --- a/Source/Particles/PulsarParameters.cpp +++ b/Source/Particles/PulsarParameters.cpp @@ -8,7 +8,7 @@ namespace PulsarParm { std::string pulsar_type; - + AMREX_GPU_DEVICE_MANAGED amrex::Real omega_star; AMREX_GPU_DEVICE_MANAGED amrex::Real ramp_omega_time = -1.0; AMREX_GPU_DEVICE_MANAGED amrex::Real B_star; @@ -24,7 +24,7 @@ namespace PulsarParm AMREX_GPU_DEVICE_MANAGED amrex::Real max_ndens; AMREX_GPU_DEVICE_MANAGED amrex::Real Ninj_fraction; AMREX_GPU_DEVICE_MANAGED amrex::Real rhoGJ_scale; - + void ReadParameters() { amrex::ParmParse pp("pulsar"); pp.query("pulsarType",pulsar_type); From 4d596f715b4cb01dc0f18cab62d7c7af1dbe1015 Mon Sep 17 00:00:00 2001 From: Revathi Jambunathan <41089244+RevathiJambunathan@users.noreply.github.com> Date: Wed, 27 Jan 2021 10:37:57 -0800 Subject: [PATCH 057/120] Pulsar add external eb (#39) * Adding pulsar input and reading pulsar parameters using Don's PR * added external E and B fields and the appropriate input parameters * EOL whitespace * seeting up bounds for pulsar surface * pushing changes for comparison * particles injected below surface, dipole magnetic field inside and outside, momentum of all particles is zero, fixed function that applied vacuum EB fields on particles * add particles based on analytical surface charge density * using local Er and Er_cor to compute particle introduction * fixing particle injection with local Er that includes Er_external * changes to pulsar * michel and li efields inside and outside star. Particle injection rho_GJ * adding input parameters to toggle rho gj scaling, ninjection, maxden * removing unwanted insidePulsarBound function * Damp electric fields internal to the pulsar when compiling with PULSAR on. * Separate out cartesian ijk -> spherical radius into a utility function so it can be used elsewhere. * Add PulsarParm::Omega(t) function that returns omega(t) depending on ramp_omega_time input parameter. If ramp_omega_time < 0, PulsarParm::Omega(t) = omega_star. * Ran the style commands suggested by Travis CI to remove trailing whitespace. * Upsating GetPosition() based on recent changes in master branch * Damp electric fields internal to the pulsar when compiling with PULSAR on. * Undo line removal. * Calling External E and B for pulsar from GetExternal functions * a few fixes in the getexternalEB and addplasma to ensure test works * fixed Ecell * removing particles if inside R_Star * recent input file * eol fix * Add functor for pulsar particle injection * fix eol * Add Functor file * fix eol * add updated input file * push external-EB-on-grid to debug. particle injection off. * inject fixed number of particles when injection is on * adding file with external EM field on grid * fix indent * fixing for loop to include last dimension * add notebook with scaling * fixing E-corotating insdie. E-quad outside. B-dipole everywhere * gather external pulsar fields, add num_ppc particles, damp Maxwell fields inside pulsar * include particles only outside r_star * fix EOL * particle injection inner ring and particle removal in same location * damp EB fields inside R_Star, intro and remove part inside R_star * fix typo in cell cell z coordinate * add fraction of particles through pcounts of cell. * Revert "add fraction of particles through pcounts of cell." This reverts commit f3daa9641d0c03eb1f86e3a5379a05df722787ae. * ensuring that fractional particle injection is uniform in cell * we dont need the p.id=-1 to remove particles 1-fractional part injection * updated input file * terminate ifdef PULSAR * remove unnecessary call to add external EB on EB Multifab. we call it directly in Fieldgather instead * clean commented out lines in GetExternalFields * remove commented out code and old unused PulsarEField and PulsarBField * remove unused function init * removing AddPulsarPlasma functor which is not used * remove commented out code and calls to add plasma functor * adding missing ; * FillBoundary for EB after dampingEB * using gpuarray for staggering used to damp EB fields * default values in fieldgather doShapeN for problo, probhi, and cur_time * empty array * pass by reference * take user-defined cc to compute r * Add Dons recommendation to change wt for fractional injection * modifying particle wt, redefining insidePulsarBoundsCC, and removing unnecessary functions * delete redundant function definition * remove redundant function definitions * remove unused variable * remove unnecesary empty line * adding user-inpu for modifying particle weight * querying input for modiyfing particle weight * remove header file decleration in Make package * remove unnecesary header * remove unused function call * use input value of star center to allow for shifted centers in the input * adding a separate file for gather pulsar external EB using grid resolution * removing Pulsar related calls from the core gather functions * call pulsar field gather separate from field gather * deposit charge is modified and therefore not const * reorder function definitions and add missingsemicolon * fix typo of variable in pulsarparameters * add the empty line back * undo any changes in FieldGather so it is the same as WarpX development * remove modifications made to fieldgather * remove unnecessary blank line in at end of file * remove tab * EOL * input parameters for damping EB and external EB to distinguish inside and outside * adding a few more input parameters * adding particle absortion radius as input * remove unnecessary print statement * add min max bounds for defining particle injection region * EOL * fix typo * fix comments from the review Co-authored-by: Donald E. Willcox Co-authored-by: Revathi Jambunathan --- .../pulsar/Pulsar_scale_RstarPhysical.ipynb | 1392 +++++++++++++++++ .../pulsar/inputs.corotating.3d.PM | 103 +- .../pulsar/pulsar_viz.ipynb | 690 ++++++++ Source/Evolve/WarpXEvolve.cpp | 31 +- Source/Initialization/InjectorPosition.H | 76 +- .../Particles/Deposition/ChargeDeposition.H | 19 + .../Particles/Deposition/CurrentDeposition.H | 57 + Source/Particles/Gather/FieldGather.H | 28 + .../Gather/GatherExternalPulsarFieldOnGrid.H | 562 +++++++ Source/Particles/Gather/GetExternalFields.H | 20 - Source/Particles/Gather/GetExternalFields.cpp | 16 - Source/Particles/MultiParticleContainer.H | 2 +- Source/Particles/PhysicalParticleContainer.H | 2 +- .../Particles/PhysicalParticleContainer.cpp | 234 ++- Source/Particles/PulsarParameters.H | 291 ++-- Source/Particles/PulsarParameters.cpp | 54 +- .../RigidInjectedParticleContainer.cpp | 1 + Source/Particles/WarpXParticleContainer.H | 1 + Source/WarpX.cpp | 4 + 19 files changed, 3142 insertions(+), 441 deletions(-) create mode 100644 Examples/Physics_applications/pulsar/Pulsar_scale_RstarPhysical.ipynb create mode 100644 Examples/Physics_applications/pulsar/pulsar_viz.ipynb create mode 100644 Source/Particles/Gather/GatherExternalPulsarFieldOnGrid.H diff --git a/Examples/Physics_applications/pulsar/Pulsar_scale_RstarPhysical.ipynb b/Examples/Physics_applications/pulsar/Pulsar_scale_RstarPhysical.ipynb new file mode 100644 index 00000000000..f87d443abb6 --- /dev/null +++ b/Examples/Physics_applications/pulsar/Pulsar_scale_RstarPhysical.ipynb @@ -0,0 +1,1392 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Overview\n", + "\n", + "This a notebook that inspects the results of a WarpX simulation.\n", + "\n", + "# Instruction\n", + "\n", + "Enter the path of the data you wish to visualize below. Then execute the cells one by one, by selecting them with your mouse and typing `Shift + Enter`" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Import statements\n", + "import yt ; yt.funcs.mylog.setLevel(50)\n", + "import numpy as np\n", + "import scipy.constants as scc\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib notebook" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#Define the Physical Constants, normalizations, and the scale-down parameter, r_scale, for the pulsar. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "######################\n", + "# physical constants #\n", + "######################\n", + "c = 299792458.0 # speed of light \n", + "q_e = 1.602176634e-19 # elementary charge\n", + "me=9.10938356*np.power(10.,-31) # electron mass\n", + "epsilon=8.8541878128*np.power(10.,-12) # permittivity of free space\n", + "mu_o = 4*3.14*1e-7 # permeability\n", + "pi = 3.14159265358979323846\n", + "SolarMass = 2e30\n", + "G = 6.674e-11 # gravitational constant\n", + "\n", + "#############################################################################\n", + "# Parameters for a real Pulsar #\n", + "# (Table 7 of J.Petri's article on Theory of Pulsar Magnetosphere and Wind) #\n", + "#############################################################################\n", + "Omega_real = 6283\n", + "B_real = 7.4E4\n", + "R_real = 12000\n", + "n_real = 6.9e16\n", + "omega_pe_real = (n_real*q_e*q_e/(me*epsilon))**0.5 #plasma frequency\n", + "SkinDepth_real = c/omega_pe_real \n", + "Mstar = 1.4*SolarMass\n", + "Rstar_skinDepth_real = 6e5\n", + "\n", + "##################\n", + "# Normalizations #\n", + "##################\n", + "Rstar_skinDepth = 6e0 # Ratio of radius of star to the skin Depth \n", + " # For a real star, this ratio is 6e5\n", + "exponent = np.arange(0,6,1) \n", + "Factor = np.array(10**exponent)\n", + "Rstar_skinDepth = np.array(6*Factor) \n", + "\n", + "RLC_Rstar = 4 # Ratio of light cylinder (where the particle speed ~ c) to Rstar\n", + " # For a pulsar with 1ms period, this ratio is 4. \n", + " # i.e., This ratio sets the omega value, since Omega*RLC = c\n", + "\n", + "# Choose skindepth as the free parameter for a choice of normalizations given above\n", + "# The skin depth below is computed from the number density for a real pulsar\n", + "# Keeping the SkinDepth constant across all the scales in our scaling study\n", + "#SkinDepth = 0.02\n", + "\n", + "# Since skin depth is maintained across the scales, and RLC/Rstar is also maintained \n", + "# lets define the decrease in the scale by comparing the value of \n", + "# (Rstar/skinDepth)/(Rstar_real/skinDepth_real)\n", + "#r_scale = Rstar_skinDepth/Rstar_skinDepth_real\n", + "\n", + "Rstar = np.ones(6)*12000\n", + "SkinDepth = Rstar/Rstar_skinDepth\n", + "r_scale = Rstar_skinDepth_real/Rstar_skinDepth" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "##################################################################\n", + "# Derive other physical parameters from the above normalizations #\n", + "##################################################################\n", + "\n", + "# 1. Lorentz Boost (dimensionless) #\n", + "# Note that in Alex Chen's paper, gamma_o ~ (1/4)*normalized_values.\n", + "# Instead here we have pi/2, since that leads to the closes gamma_o \n", + "# value for a real 1ms pulsar. \n", + "gamma_o = (pi/2)*(Rstar_skinDepth)**2/RLC_Rstar \n", + "\n", + "\n", + "gamma_real = (pi/2)*6e5**2/RLC_Rstar;\n", + "gamma_scaling = gamma_o/(gamma_real) # This is to see how the gamma value \n", + " # decreases due to decrease in the ratio of R_star to skin depth\n", + "\n", + "\n", + "\n", + "# 3. Light cylinder location (m)\n", + "RLC = Rstar*RLC_Rstar\n", + "# 4. Angular Frequency (rad/s)\n", + "# Omega remains constant\n", + "Omega = c/RLC\n", + "# 5. Period (s)\n", + "# Period remains constant\n", + "Period = 2*3.14/Omega\n", + "# Moment of inertia for a sphere = (2/5)MR^2 (kg.m^2)\n", + "# Note that when the Rstar is scaled by r_scale, \n", + "# Mstar decreases as r_scale^3. Thus Mstar*r_scale**3 is the \n", + "# mass of the scaled down star.\n", + "# I remains constant across all scales\n", + "I = (2/5)*(Mstar)*Rstar**2\n", + "# 6. Rotation induced potential drop from pote to equator (V)\n", + "# Reference: Alex Chen's 2014 paper\n", + "# Scales as 1/r_scale**2\n", + "phi_o = gamma_o * (me/q_e) * c**2\n", + "\n", + "# Braking is the rate of slow-down of the spin. \n", + "# It is not relevant for the scaling. \n", + "# However, 1e-15 is the P_dot for a pulsar with P=1s\n", + "# and the rate of slowdown decreases proportional to the period. \n", + "# So we were to compare two stars with same radius, but different Omega\n", + "# then we can use Braking to determine the magnetic field strength at the surface as follows\n", + "# Bo = (3*mu_o*c*c*c/(32*pi*pi*pi))**0.5 * (I*Braking*Period)**0.5/(Rstar**3) \n", + "# (Reference : Table 7 of Jetri's article)\n", + "# Remains constant across all scales\n", + "Braking = 1e-15*Period\n", + "\n", + "# 7. Magnetic field strength (Tesla)\n", + "# Bo decreases as ~ 1/r_scale**2\n", + "Bo = phi_o/(Rstar*Rstar*Omega)\n", + "\n", + "# 8. Volume charge density (C/m^3) for uniform magnetization insize the star \n", + "# Refer to Table 7 of Petri's article \n", + "# Since Omega increases as r_scale and Bo decreases as r_scale\n", + "# The product of Omega*Bo remains constant across all scales. \n", + "# Thus, rho_e decreases as (1/r_scale**2)\n", + "rho_e = 2*epsilon*Omega*Bo #(Not adding the negative sign here)\n", + "\n", + "# 9. Electron number density (#/m^3)\n", + "# ne decreases as (1/r_scale**2)\n", + "ne = rho_e/q_e\n", + "# 9a. plasma frequency \n", + "# decreases as (1/r_scale)\n", + "omega_pe = (ne*q_e*q_e/(me*epsilon))**0.5 #plasma frequency\n", + "# 10. Magnetic moment (Am^2)\n", + "# decreases as (1/r_scale**2)\n", + "magnetic_moment = Bo*Rstar*Rstar*Rstar*4*pi/(mu_o)\n", + "# 11. E-field (V/m)\n", + "# Efield decreases as (1/r_scale**2)\n", + "E = Omega*Bo*Rstar\n", + "\n", + "\n", + "#########################################\n", + "# How do the energies and forces scale? #\n", + "#########################################\n", + "# 12. Magnetic Energy (J)\n", + "# Magnetic energy decreases as (1/r_scale**4)\n", + "magnetic_energy = (4*pi/3)*Bo**2*Rstar**3/(2*mu_o)\n", + "\n", + "# 13. Gravitational Potential Energy (J)\n", + "# G.pot energy remains constant \n", + "GP_energy = (3/5)*G*Mstar*Mstar/(Rstar)\n", + "\n", + "# 14. Gravitational to Electric force (dimensionless)\n", + "# This ratio increases as r_scale**2\n", + "G_EForce = G*Mstar*me/(Rstar*Rstar*q_e*E)\n", + "\n", + "# 15. Rotational kinetic energy \n", + "# Rot. KE remains constant\n", + "rotational_KE = (1/2)*I*Omega**2\n", + "\n", + "# 16. From (12) and (13), we know the B.energy scales as (1/r_scale**4) and GP energy is constant \n", + "# Thus the ratio of GP_energy and B_energy increases as r_scale**4\n", + "GB_energy_ratio = GP_energy/magnetic_energy\n", + "\n", + "# 17. Rate of change of Omega, or angular acceleration decreases as 1/r_scale**4\n", + "Omega_dot = Bo*Bo*Rstar**6*Omega**3/(I) * (32*pi/(3*mu_o*c**3))* (1/(4*pi*pi))\n", + "\n", + "# 18. Torque decreases as 1/r_scale**4\n", + "Torque = I * Omega_dot\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Input parameters for WarpX for geometry scaled down by r_scale = [1.e-05 1.e-04 1.e-03 1.e-02 1.e-01 1.e+00]\n", + "Lorentz factor, (gamma_o) = [1.41371669e+01 1.41371669e+03 1.41371669e+05 1.41371669e+07\n", + " 1.41371669e+09 1.41371669e+11]\n", + "Rstar (m) [12000. 12000. 12000. 12000. 12000. 12000.]\n", + "Omega (rad/s) [6245.67620833 6245.67620833 6245.67620833 6245.67620833 6245.67620833\n", + " 6245.67620833]\n", + "Bo (Tesla) [8.03230942e-06 8.03230942e-04 8.03230942e-02 8.03230942e+00\n", + " 8.03230942e+02 8.03230942e+04]\n", + "ne (/m^3) [5.54482989e+06 5.54482989e+08 5.54482989e+10 5.54482989e+12\n", + " 5.54482989e+14 5.54482989e+16]\n", + "Size of the domain, (m) [360000. 360000. 360000. 360000. 360000. 360000.]\n", + "Minimum cell size (m) [2.e+03 2.e+02 2.e+01 2.e+00 2.e-01 2.e-02]\n", + "timestep (s) [3.76386776e-06 3.76386776e-07 3.76386776e-08 3.76386776e-09\n", + " 3.76386776e-10 3.76386776e-11]\n", + "Numver of cells assuming unif. grid, [1.8e+02 1.8e+03 1.8e+04 1.8e+05 1.8e+06 1.8e+07]\n" + ] + } + ], + "source": [ + "############################################################\n", + "# Print all the values that will be used as input in WarpX #\n", + "############################################################\n", + "print(\"Input parameters for WarpX for geometry scaled down by r_scale = \", Rstar_skinDepth/Rstar_skinDepth_real)\n", + "print(\"Lorentz factor, (gamma_o) = \", gamma_o)\n", + "print(\"Rstar (m)\", Rstar)\n", + "print(\"Omega (rad/s)\", Omega)\n", + "print(\"Bo (Tesla)\", Bo)\n", + "print(\"ne (/m^3)\", ne)\n", + "print(\"Size of the domain, (m)\", 30*Rstar)\n", + "print(\"Minimum cell size (m)\", SkinDepth)\n", + "print(\"timestep (s)\", 0.5*omega_pe**-1) # Or may be cfl criterion\n", + "print(\"Numver of cells assuming unif. grid, \", 30*Rstar/SkinDepth)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gravitational force to E-force : [1.22562947e-02 1.22562947e-04 1.22562947e-06 1.22562947e-08\n", + " 1.22562947e-10 1.22562947e-12]\n", + "Gravitational energy to B-energy : [1.40727411e+38 1.40727411e+34 1.40727411e+30 1.40727411e+26\n", + " 1.40727411e+22 1.40727411e+18]\n", + "B energy, (J) [1.85906071e+08 1.85906071e+12 1.85906071e+16 1.85906071e+20\n", + " 1.85906071e+24 1.85906071e+28]\n", + "Gravitational potential energy, (J) [2.616208e+46 2.616208e+46 2.616208e+46 2.616208e+46 2.616208e+46\n", + " 2.616208e+46]\n", + "Rotational Kinetic Energy (J) [3.14564313e+45 3.14564313e+45 3.14564313e+45 3.14564313e+45\n", + " 3.14564313e+45 3.14564313e+45]\n" + ] + } + ], + "source": [ + "#############################################################\n", + "# Print ratios of G.Pot.Energy/B_energy and G.Force/E_force #\n", + "#############################################################\n", + "print(\"Gravitational force to E-force : \", G_EForce)\n", + "print(\"Gravitational energy to B-energy : \",GB_energy_ratio)\n", + "\n", + "\n", + "# Print dimensional values of energies\n", + "print(\"B energy, (J)\",magnetic_energy);\n", + "print(\"Gravitational potential energy, (J)\", GP_energy)\n", + "print(\"Rotational Kinetic Energy (J)\", rotational_KE )\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support. ' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('
');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '
');\n", + " var titletext = $(\n", + " '
');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('
');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('
');\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('