Xin's version with added functions

README.md

@@ -11,15 +11,14 @@ These are the Python bindings for the [NEST library](https://github.com/NESTColl
 
 You do *not* have to have NEST already installed to use this package.
 
-## Installing from PyPI
+## Note from Xin:
+This package is forked from [nestpy](https://github.com/NESTCollaboration/nestpy) and updated to LUX Run3 Detector template. In addition,  two functions are added to `testNEST.cpp`. 
+1. runNEST() --- A function that takes in an energy and a position as the inputs, and output (S1, S2) observables
+2. runNEST_vec() --- A vectorized function that takes in a list of energies and positions as the inputs, and outputs a list of s1, s2 variables. 
 
-For 64-bit Linux or Mac systems, instally 'nestpy' should just require running:
+Additionally, all NEST built-in spectrum are binded as well. User has direct access to the various spectra.
 
-```
-pip install nestpy
-```
-
-You can then test that it works by running the example above.
+Please see `example/demo_v0.ipynb` for the usage.
 
 ## Installing from source
 
@@ -28,11 +27,12 @@ Requirements: You must have CMake>=2.8.12 and a C++11 compatible compiler (GCC>=
 First, you must check out this repository then simply run the installer:
 
 ```
-git checkout https://github.com/NESTCollaboration/nestpy
+git clone https://github.com/xxiang4/nestpy.git
 cd nestpy
 python setup.py install
 ```
 
+
 ## Usage
 
 Python bindings to the NEST library:

examples/demo_v0.ipynb

@@ -0,0 +1,226 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import nestpy\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import time"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "T_Kelvin: 173.0\n",
+      "radius: 200.0\n",
+      "dt_min: 80.0\n",
+      "dt_max: 130.0\n",
+      "anode: 549.2\n",
+      "cathode: 55.9\n",
+      "T_Kelvin: 173.0\n",
+      "p_bar: 1.57\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "#create detector\n",
+    "detector = nestpy.DetectorExample_LUX_RUN03()\n",
+    "\n",
+    "# inspect detector parameters\n",
+    "z_max = detector.get_TopDrift() \n",
+    "radius = detector.get_radius() # right fid radius?? TBD\n",
+    "dt_min = detector.get_dt_min() # right min dt?? TBD\n",
+    "dt_max = detector.get_dt_max() # right max dt?? TBD\n",
+    "anode = detector.get_anode()\n",
+    "cathode = detector.get_cathode()\n",
+    "T_Kelvin = detector.get_T_Kelvin() \n",
+    "p_bar = detector.get_p_bar() \n",
+    "\n",
+    "# print detector parameters (satisfied with the setting?)\n",
+    "print('T_Kelvin:', T_Kelvin)\n",
+    "print('radius:', radius)\n",
+    "print('dt_min:', dt_min)\n",
+    "print('dt_max:', dt_max)\n",
+    "print('anode:', anode)\n",
+    "print('cathode:', cathode)\n",
+    "print('T_Kelvin:', T_Kelvin)\n",
+    "print('p_bar:', p_bar)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "6.532790408546776 590.173217059425\n"
+     ]
+    }
+   ],
+   "source": [
+    "# run a single recoil\n",
+    "keV=10\n",
+    "type_num = nestpy.INTERACTION_TYPE(0) # NR\n",
+    "pos_x, pos_y, pos_z = 0., 0., z_max/2.\n",
+    "inField=180\n",
+    "\n",
+    "obs = nestpy.runNEST(\n",
+    "    detector, \n",
+    "    keV, \n",
+    "    type_num, \n",
+    "    inField, \n",
+    "    pos_x, \n",
+    "    pos_y, \n",
+    "    pos_z, \n",
+    "    seed=0\n",
+    "    )\n",
+    "\n",
+    "s1c_phd = obs.s1c_phd\n",
+    "s2c_phd = obs.s2c_phd\n",
+    "print(s1c_phd, s2c_phd)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# run many recoils with vectorized arguments\n",
+    "\n",
+    "# somehow detector is deleted once runNEST is finished\n",
+    "\n",
+    "n_events=100\n",
+    "keV=np.linspace(0, 100, n_events)\n",
+    "type_num = nestpy.INTERACTION_TYPE(0) # NR\n",
+    "\n",
+    "# uniformly sample (x,y,z) in cylindar colume\n",
+    "r2 = np.random.uniform(low=0, high=radius*radius, size=n_events)\n",
+    "r = np.sqrt(r2)\n",
+    "phi = np.random.uniform(low=0, high=2*np.pi, size=n_events)\n",
+    "pos_x = r * np.cos(phi);\n",
+    "pos_y = r * np.sin(phi);\n",
+    "pos_z = np.random.uniform(low=0, high=z_max, size=n_events)\n",
+    "\n",
+    "inField=180\n",
+    "obs_arr = nestpy.runNEST_vec(\n",
+    "    nestpy.DetectorExample_LUX_RUN03(), \n",
+    "    keV.tolist(), \n",
+    "    type_num, \n",
+    "    inField, \n",
+    "    pos_x.tolist(), \n",
+    "    pos_y.tolist(), \n",
+    "    pos_z.tolist(), \n",
+    "    0\n",
+    "    )\n",
+    "\n",
+    "s1 = np.array(obs_arr.s1c_phd)\n",
+    "s2 =np.array(obs_arr.s2c_phd)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# apply a detector cut and plot it\n",
+    "cut_mask = np.logical_and(s2>0, s1>0)\n",
+    "plt.scatter(s1[cut_mask], np.log10(s2[cut_mask]))\n",
+    "plt.xlabel('s1 [phd]')\n",
+    "plt.ylabel('log10(s2 [phd])')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# example of using NEST recoil generators"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# NEST WIMP spectrum comes from: \n",
+    "# Phys. Rev. D 82 (2010) 023530 (McCabe)\n",
+    "\n",
+    "Er = np.linspace(0.01, 3, 400)\n",
+    "\n",
+    "spec = nestpy.TestSpectra()\n",
+    "WIMP_dRate_vec = np.vectorize(spec.WIMP_dRate)\n",
+    "\n",
+    "\n",
+    "dR_3GeV = WIMP_dRate_vec(Er, m_GeV=3)\n",
+    "dR_6GeV = WIMP_dRate_vec(Er, m_GeV=6)\n",
+    "dR_10GeV = WIMP_dRate_vec(Er, m_GeV=10)\n",
+    "\n",
+    "plt.plot(Er, dR_3GeV, label='3 GeV')\n",
+    "plt.plot(Er, dR_6GeV, label='6 GeV')\n",
+    "# plt.plot(Er, dR_10GeV, label='10 GeV')\n",
+    "plt.legend()\n",
+    "plt.yscale('log')\n",
+    "plt.title('$\\sigma=10^{-36}$ cm$^2$')\n",
+    "plt.xlabel('Er [keVnr]')\n",
+    "plt.ylabel('dR/dE [counts/(kg-d-keV)]')\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "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.6.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}