From 8f74088debf5b2ea0d650aa7e691e38a585d3f1f Mon Sep 17 00:00:00 2001 From: weichangfeng Date: Fri, 4 Dec 2020 08:10:51 +0800 Subject: [PATCH] Upload New File --- ...in_Korean_BBH_waveform_test_20201204.ipynb | 443 ++++++++++++++++++ 1 file changed, 443 insertions(+) create mode 100644 VItamin_Korean_BBH_waveform_test_20201204.ipynb diff --git a/VItamin_Korean_BBH_waveform_test_20201204.ipynb b/VItamin_Korean_BBH_waveform_test_20201204.ipynb new file mode 100644 index 0000000..c16624a --- /dev/null +++ b/VItamin_Korean_BBH_waveform_test_20201204.ipynb @@ -0,0 +1,443 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is a notebook to generate Korean BBH waveforms for VItamin box to test. \n", + "We produce random injection parameters first, and Minke will give waveforms. Then we whiten the waveforms and add Gaussian noise." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import minke.sources\n", + "import lalsimulation\n", + "import lal\n", + "import numpy as np\n", + "import minke.distribution\n", + "import matplotlib.pyplot as plt\n", + "import bilby\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "nr_path = './h_psi4/{}'\n", + "waveforms_merge = {\n", + " 1: \"h_m1_L0.9_l2m2_r300.dat\",\n", + " 2: \"h_m2_L0.87_l2m2_r300.dat\",\n", + " 4: \"h_m4_L0.5_l2m2_r300.dat\",\n", + " 8: \"h_m8_L0.35_l2m2_r280.dat\",\n", + " 16: \"h_m16_L0.18_l2m2_r300.dat\"\n", + "}\n", + "nr_waveform = waveforms_merge[1]\n", + "\n", + "duration = 1\n", + "sampling_frequency = 256\n", + "Nt=duration*sampling_frequency\n", + "\n", + "ref_geocent_time = 1126259642.5\n", + "start_time = ref_geocent_time-duration/2.0\n", + "epoch = str(start_time)\n", + "\n", + "\n", + "np.random.seed(8870)\n", + "num_samples = 4\n", + "locations = minke.distribution.uniform_sky(num_samples)\n", + "distances = np.random.uniform(1000, 3000, num_samples)\n", + "total_mass = 115" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([5.61082165, 1.81307954, 5.21336446, 4.87517282]),\n", + " array([-0.06602056, 0.6080421 , -0.94677179, -0.22614099]),\n", + " array([6.08466421, 0.80840669, 2.17605961, 4.17999942]))" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "locations" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([2236.22809678, 1896.83491489, 2874.28498328, 1554.5007441 ])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "distances" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def generate_for_detector(source, ifos, num_samples, sampling_frequency, epoch, distance, total_mass, ra, dec, psi):\n", + " \"\"\"\n", + " Generate an injection for a given waveform.\n", + " \n", + " Parameters\n", + " ----------\n", + " source : ``minke.Source`` object\n", + " The source which should generate the waveform.\n", + " ifos : list\n", + " A list of interferometer initialisms, e.g. ['L1', 'H1']\n", + " sampling_frequency : int\n", + " The sampling_frequency in hertz for the generated signal.\n", + " epoch : str\n", + " The epoch (start time) for the injection.\n", + " Note that this should be provided as a string to prevent overflows.\n", + " distance : float\n", + " The distance for the injection, in megaparsecs.\n", + " total_mass : float\n", + " The total mass for the injected signal.\n", + " ra : float\n", + " The right ascension of the source, in radians.\n", + " dec : float\n", + " The declination of the source, in radians.\n", + " psi : float\n", + " The polarisation angle of the source, in radians.\n", + " \n", + " Notes\n", + " -----\n", + " This is very much a draft implementation, and there are a number of \n", + " things which should be tidied-up before this is moved into Minke,\n", + " including bundling total mass with the source.\n", + " \"\"\"\n", + " nr_waveform = source.datafile\n", + " y_data_noisy_array = np.zeros((num_samples,3,256))\n", + " \n", + " waveform = {}\n", + " waveform['signal'] = {}\n", + " waveform['times'] = {}\n", + " \n", + " for ifo in ifos:\n", + " \n", + " det = lalsimulation.DetectorPrefixToLALDetector(ifo)\n", + " hp, hx = source._generate(half=True, epoch=epoch, rate=sampling_frequency)[:2]\n", + " h_tot = lalsimulation.SimDetectorStrainREAL8TimeSeries(hp, hx, ra, dec, psi, det)\n", + " waveform['signal'][ifo] = h_tot.data.data.tolist()\n", + " waveform['times'][ifo] = np.linspace(0, len(h_tot.data.data)*h_tot.deltaT, len(h_tot.data.data)).tolist()\n", + " \n", + " \n", + " return waveform" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "waveforms = []\n", + "ifos_list = ['H1','L1','V1']\n", + "for distance, location in zip(distances, np.vstack(locations).T):\n", + " \n", + " hyper_object = minke.sources.Hyperbolic(\n", + " datafile = nr_path.format(nr_waveform),\n", + " total_mass = total_mass,\n", + " distance = distance,\n", + " )\n", + " hyper_object.datafile = nr_waveform\n", + " \n", + " waveform = generate_for_detector(hyper_object, ifos_list, num_samples, sampling_frequency, epoch, distance, total_mass, *location)\n", + " waveforms.append(waveform)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# We need to pad the beginning of the waveform with zeros \n", + "def pad_waveform(ifos,num_samples,waveforms):\n", + " for i in range(num_samples):\n", + " for ifo in ifos_list: \n", + " for j in range(256-len(waveforms[i]['signal'][ifo])):\n", + " waveforms[i]['signal'][ifo] = waveforms[i]['signal'][ifo] + [0] \n", + " return waveforms" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "waveforms = pad_waveform(ifos_list,num_samples,waveforms)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/weichangfeng/.local/lib/python3.8/site-packages/bilby/gw/detector/psd.py:356: RuntimeWarning: invalid value encountered in multiply\n", + " frequency_domain_strain = self.__power_spectral_density_interpolated(frequencies) ** 0.5 * white_noise\n" + ] + } + ], + "source": [ + "ifos = bilby.gw.detector.InterferometerList(ifos_list)\n", + "ifos.set_strain_data_from_power_spectral_densities(\n", + " sampling_frequency=sampling_frequency, duration=duration,\n", + " start_time=ref_geocent_time-duration/2.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def whiten_signal(signal, ifo):\n", + " \n", + " signal_fd = np.fft.rfft(signal)/Nt\n", + " \n", + " whitened_signal_fd = signal_fd/ifo.amplitude_spectral_density_array\n", + " whitened_signal_td = np.sqrt(2.0*Nt)*np.fft.irfft(whitened_signal_fd)\n", + " \n", + " return whitened_signal_td" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "whitened_signal_td_array=np.zeros((num_samples,3,256))\n", + "\n", + "for i in range(num_samples):\n", + " k = 0\n", + " for ifo in ifos_list:\n", + " whitened_signal_td_array[i][k,:] = whiten_signal(waveforms[i]['signal'][ifo],ifos[k])\n", + " k += 1\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'waveform')" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEWCAYAAAB42tAoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAAo5UlEQVR4nO3deZxcdZ3u8c9T1Vs6+wYJEAhLBBQBsQERdRBckFFRBsRlRFwu4zi4zMx11HGuOtxxRq+O475kgEFcQGVEoyAREARHEMK+RPYtIUh2knQ63dX1vX+cU93VnerqSnd1V/fJ8369+tWnTp069TtJdz/1W48iAjMzs6HkGl0AMzOb2BwUZmZWlYPCzMyqclCYmVlVDgozM6vKQWFmZlU5KMzMrCoHhdkYkPS4pFcN2tci6bL0uZB0QmNKZ7ZrHBRm4+t3wF8CzzS6IGa1amp0Acx2FxHRDXwZQFJvY0tjVjvXKMzMrKrMBoWkCyU9K+neOpzrSEk3SbpP0t2SzqxwzFclbR3te5mZTTSZDQrgIuDkOp2rEzgrIl6QnvPLkmaVnpTUAcyu03uZmU0omQ2KiLgB2FC+T9KBkq6SdJukGyUdUuO5HoyIh9Ltp4FngfnpOfPAF4B/qOsFmJlNELtbZ/ZS4P0R8ZCkY4FvAifuygkkHQO0AI+ku84FlkXEGkl1LaxNes2S2soeF4A8UPpBaUmf3xFe798msN0mKCRNA14K/KTsD3pr+txpwHkVXrY6Il5bdo6FwPeAd0VEUdJewBnACWNYdJu8rhz0+LMkQ2P3Sx8vT7/vDzw+TmUy22XK8gcZSYuBX0bEYZJmAA9ExMIRnmsGcD3wrxFxWbrvz4ELgK70sH2BRyPioNGW3cxsoshsH8VgEfEc8JikMwCUOKKW10pqAS4HLi6FRHrOKyJiQUQsjojFQKdDwsyyJrNBIekS4CbgYEmrJL0XeAfwXkl3AfcBp9Z4urcArwDOlnRn+nXkWJTbzGyiyXTTk5mZjV5maxRmZlYfmRz1NG/evFi8eHGji2FmNmncdttt6yJifqXnMhkUixcvZsWKFY0uhpnZpCHpiaGec9OTmZlV5aAwM7OqHBRmZlaVg8LMzKpyUJiZWVUOCjMzq8pBYWZmVTkozOrk6U3bue6Pzza6GGZ156Awq5Pv3/wEf/PD2xtdDLO6c1CY1UlPb5FCrxfZtOxxUJjVSQQUvRqzZZCDwqxOig4KyygHhVmdBEHROWEZ1NCgkHShpGcl3TvE8ydI2lx2V7lPjXcZzWpVqkz4ZmCWNY1eZvwi4OvAxVWOuTEiXj8+xTEbuVJAFAPyanBhzOqooTWKiLgB2NDIMpjVS6nZyf0UljWToY/iOEl3SfqVpBcMdZCkcyStkLRi7dq141k+MyDpowAHhWXPRA+K24H9IuII4GvAz4Y6MCKWRkRHRHTMn1/xbn5mY6rY10fR2HKY1duEDoqIeC4itqbbVwLNkuY1uFhmFfX3UTgpLFsmdFBIWiBJ6fYxJOVd39hSmVUWfX0UjS2HWb01dNSTpEuAE4B5klYBnwaaASLi28DpwF9LKgDbgbeGxx7aBFV0jcIyqqFBERFvG+b5r5MMnzWb8PrmURQbWw6zepvQTU9mk4mHx1pWOSjM6qQ0PNYxYVnjoDCrk3CNwjLKQWFWJx4ea1nloDCrE0+4s6xyUJjVSSkfXKOwrHFQmNVJsWz1WLMscVCY1UlfH4WTwjLGQWFWJ+E+CssoB4VZnXgJD8sqB4VZnXgehWWVg8KsTopePdYyykFhVjfpEh6uUVjGOCjM6sQ1CssqB4VZnXgJD8sqB4VZnXiZccsqB4VZnZTiwTlhWeOgMKsTNz1ZVjkozEZhS1fPTgHhzmzLmoYGhaQLJT0r6d4hnpekr0p6WNLdko4a7zKaDWXz9h6O/uw1XLvyWcAT7iy7Gl2juAg4ucrzrwOWpF/nAN8ahzKZ1WRTZzddPUUeXbcV6A8Iz6OwrGloUETEDcCGKoecClwciZuBWZIWjk/pzKrr6U0CYVNnD1Beo2hUiczGRqNrFMPZG3iq7PGqdJ9ZwxWKRQA2Dg4KJ4VlzEQPippJOkfSCkkr1q5d2+ji2G6g0Fej6AYgcGe2ZdNED4rVwKKyx/uk+3YSEUsjoiMiOubPnz8uhbPdW09vUqMoNT313zPbSWHZMtGDYhlwVjr66SXA5ohY0+hCmUF/H8XGUo3Cw2Mto5oa+eaSLgFOAOZJWgV8GmgGiIhvA1cCpwAPA53AuxtTUrOdFYaoUXh4rGVNQ4MiIt42zPMB/M04Fcdsl/SkybBpe6mPIuGgsKyZ6E1PZhNWqUbR1VOkq6e3r+nJOWFZ46AwG6FSHwUkzU99E+5wUli2OCjMRqg0jwKSDu3+eRQNKpDZGHFQmI1QaXgsJEHhzmzLKgeF2QiVNz1t7uzx8FjLLAeF2QgVyoJiY2dPX9OTJ9xZ1jgozEZopz4KL+FhGeWgMBuhgaOe3Edh2eWgMBuh0jyKtuYcXT1F3wrVMstBYTZCpVFPLfkcxYiyPooGFspsDDgozEao1PTU0pSnGF7Cw7LLQWE2QoVikXxO5HPJSKeih8daRjkozEao0Bs050VOGtD05BqFZY2DwmyEenqD5lwuDYr+gPA8CssaB4XZCBWKRZryQmJQjaKx5TKrNweF2Qj19BZpyic1igg8PNYyy0FhNkJJ05PIpTWKomsUllEOCrMRKpTVKJLhse6jsGxq6K1QzSaznmIkfRQMqlG4SmEZ4xqF2QgVeou09PVRuDPbsquhQSHpZEkPSHpY0scrPH+2pLWS7ky/3teIcppVUuhNahQ5iWLRndmWXQ1repKUB74BvBpYBdwqaVlE3D/o0B9FxLnjXkCzYfQUg6ZcjoJ66Y3+O2U7JyxrGlmjOAZ4OCIejYhu4FLg1AaWx2yX9BSKfTOzBy7h4aSwbGlkUOwNPFX2eFW6b7C/kHS3pMskLRrqZJLOkbRC0oq1a9fWu6xmOykUizTlcuRySb+E+ygsqyZ6Z/YvgMURcThwNfDdoQ6MiKUR0RERHfPnzx+3Atruqyfto8inaz25RmFZ1cigWA2U1xD2Sff1iYj1EbEjfXg+8OJxKpvZsArFIs35HCrNo/A9sy2jGhkUtwJLJO0vqQV4K7Cs/ABJC8sevhFYOY7lM6uqf/VY0uGxXmbcsqlho54ioiDpXGA5kAcujIj7JJ0HrIiIZcCHJL0RKAAbgLMbVV6zwXoGzMwuX8LDSWHZ0tCZ2RFxJXDloH2fKtv+BPCJ8S6XWS3613pK51H0LeHR4IKZ1dlE78w2m7BKaz1p0KKAW7oKvPpLv+WupzY1tHxm9eKgMBuhnmKUzaOg76bZ9z69mYee3cp5vxw8d9RscnJQmI1Qobd8HkX/8NjprUmL7totO6q93GzScFCYjVAy6qm/M7vUNVFI26AcFJYVDgqzEeopJkt4aNA9s3t6iwBs7+ltZPHM6sZBYTZCPX2rxzJgmfFSUJT88u6n+bsf3Tn+BTSrEweF2QhEBL3p6rE5id6yMbE9vTHguJseWc8V96xpRDHN6qKmeRSS9gc+CCwuf01EvHFsimU2sZXCoDQzu9BbHhT9NYqNnT3sKBTZUSjSWwzyOY17Wc1Gq9YJdz8DLiBZpK9Y/VCz7CsUk1+DpnStp95i5aBYs3k7OwrJ487uAtPbmse3oGZ1UGtQdEXEV8e0JGaTSKlG0ZRLVo8dGBT9289s7qK7kHRqd3b3OihsUqo1KL4i6dPAr4G+MX8RcfuYlMpsgiuktYaWpmQexcA+ivIaRVdfjWLbjsL4FtKsTmoNihcC7wROpL/pKdLHZrud/hpF0vQ0VB/FM5u72NFTanrycFmbnGoNijOAA9Jblprt9kph0JQu4VEcYtTTlq4edqRNT65R2GRV6/DYe4FZY1gOs0mlNPu6b9TTEJ3ZXT3Fss5s1yhscqq1RjEL+KOkWxnYR+HhsbZbKvVRlOZRFIcKikJvfx9Ft2sUNjnVGhSfHtNSmE0y5fMotFONItlubcqxvbu3r+mpc4drFDY5DRsUkvLAdyLikHEoj1nddBeKtDTl6OrpRYLWpnzdJr31zaOoUKMoDZWd1tpEV6FId9k8CrPJaNigiIheSQ9I2jcinhyPQplV0l0osmFbN+u2Jq2fz3X1sHLNFg6YN5Xl9z3DfnOn8sjarTzwzBZedeiefOO6h3nfy/dn2V1PM3dqC689bAEX3PgYP37/cXz/5id484v25vB9Zo2oLKXmpeam3E59FCVTW5vo6i5venKNwianWpueZgP3SboF2Fba6T4KG62unl7Wbd3Buq3drNuyg3Vbd7A2/b5uazdrtybb67d2s3l7z5DnaWvO0dVTJJ8T09ua+I9rHmTetFa+ef0jtDblWLVxO3et2gzAGd++iQ3burlv9XMcs/8cHvjTFv7zrI5dKndf01N6K9TeoYKi0Ns3PHbrjgIX/c9jnNGxiKmtDb0LsdkuqfWn9f+MaSksM3p6i2zq7GFjZzcbt3Un3zt7+kNg6w7Wbenu297SVbk5ZnpbE/OntTJvWiuHLJjOvHR77rQW5k1rJQLyOXHowuk88MwWOvabw2Prt9GSzzFvegu/fWAtbzhiL751/SO8fMk8rln5LLc8tp4X7zeb/7zxMeZNa+WWxzdw6xMbiIBH125lzeYujjtgLrkamqZK8yb6lvCocKPsqS15Nm/vHx5786PruePJTTQ35XjHsfsByfDZGx9axykvXDjSf3KzMVdTUETEbyXtCRyd7rolIp4d7ZtLOhn4CpAHzo+Izw16vhW4GHgxsB44MyIeH+372vC6C0We6+phS1eBLV09PLe9wHNd5QHQ0xcEGzp72NTZzYZt3UP+4QeY0dbEvOnJH/xDF87gFdNbmZf+4Z83rTV9Lnnc1pyvuaz7zG4H4Mj2WX37zuhYBMDfvvp5AHQsngMkNZhFc9p55cF78Nov30BLU45NnT28//u38eCftnLBuzo46dA9h33PnmL5PAoq1iimtTWxetP2vntpP74uqYzf9dQmbntiI3PaW5g9tYUvLH+AKz/0cj6z7D7e87L9ecFeM9iwrZsjFs2is7tAe4trH9ZYta4e+xbgC8D1gICvSfpoRFw20jdOO8m/AbwaWAXcKmlZRJTfaPi9wMaIOEjSW4HPA2eO9D2zLCLY3tNLZ3cv27uT753dBbZ397KtbLuzu5dtOwps2VHgue1JEDzX1cNzaSBs6Ur2l9rVhzK1Jc+s9hbmTG1hVnszi+e2M7u9Jfma2rzT9pypLbv0x3+stDXnOeu4xQB84+1HMWNKM+f98n7uemoTkHzqryUoCn1NT0lndiVTW5sGNJdt7Ey2f//IetZs7mLmlGYO32cmABf87jFueXwDbS15isXgzqc28c13HMV7LrqVi997DL+8ew0H7zmdYw+Yw1X3PsO5rzyIq+57huMOmEtvMdhRKLLP7Cls2NbN3GmtI/3nMauo1o8qnwSOLtUiJM0HrgFGHBTAMcDDEfFoes5LgVOB8qA4FfhMun0Z8HVJiqhQz6+D9333VrrS9uSg/0Y0Ecnj/u1U6fnyY0n+aPdvDzgUym6ZudN5K5yDoY4FdhSSUNi2o3eX76bW2pRjxpRmprc1MaOtmRltTewzawozpjQxPX08va05edyaHjeluS8YWpsa/0d/tF55yB4AvOnIvVi55jkWzmzjlsc2sGbzdtpbmpg5ZegF/EojmVrSzuxKprbkK06yW7VxOwAbtnVz40PrAPjZnasBuOmRdfQWg2LAhy+9g0Ix+OhP7mb1pu205HMsnNXGE+s7+e2Da7njyU0csmA667d1s7WrwPEHzeOalX/ilBcu4K6nNvc10z2+fhuHLpjBs1u6iEjK7OXOs2nmlGa+/vaj6n7eWoMiN6ipaT2jv+nR3sBTZY9XAccOdUxEFCRtBuYC6wafTNI5wDkA++6774gKtG1HMuZd6SdEAaUPi0LJjvL9SveTjKUvP7b8Q2b5+Uhfq7LnyveXnhl4zM7nLQ33nNKSp705T3tLniktTbS35NOvpnRfvm/flJam5NjWfCb+0NfLWcct5g1H7MV3f/8437z+EV73lRs58ZA9+NJbjhzyNd29SQCUboVaybTWoYNmSnOe7T299BajryO+tA9gdnszGzt7WDCjjdWbtrPH9Fa2dBV4Yn0nhyyYzh1PbuKIRbO4Z9UmZre3sN/cdq5Z+SdOPGQPfnXvMxyxzyy2dCV9QwcvmM7dqzexcOYUmvOiu1Cs2Kdik1/TGH0AqDUorpK0HLgkfXwmcOWYlGiEImIpsBSgo6NjRL8Fl5zzkrqWySaHfE7Mm9bKMfvP4Wu/eZhNnT3cu3pz1deU1yiG+nQ+rXXnMF4wo41nnuviNS/Ykzue3MSTGzp5S8ciLr7pCd52zL5cdttT7DVrCm9+0d78+9UPcuHZR3PuJbfzoROXEARPrO/k3S/dn0tvfZK3H7svf3xmC3tOb2Pe9BZWb9zOkj2ns2FbN7Pbm4cMMLNdVTUoJLVGxI6I+Kik04CXpU8tjYjLR/neq4FFZY/3SfdVOmaVpCZgJkltxqzuXrzfbOZNa6W9Jc+ja7f1TdirpDvto6jW9NReNgQ2n0uG0D5vwXQ+/KolHLP/HL530xNc+8c/8c6X7McltzzJKS9cwMuXzGPGlGaOXDSLU4/cmwUz2/jN35+w07n/6s8OBODotJMeYMme0wGYM7VlJJdvNqThahQ3AUdJ+l5EvBP4aR3f+1ZgSXqb1dXAW4G3DzpmGfCutBynA78Zq/4Js/aWJm75x5P4xd1P8+FL7+Sxdds4eMH0iseWahSt+XzFzuycoL2lv0Yxu72FdVt3MH9aK287Jmka/cQph/C3r34eM6c0c89nXrtTZ/+CmW31ujSzURkuKFokvR14aVqjGCAiRhwcaZ/DucBykuGxF0bEfZLOA1ZExDKS269+T9LDwAaSMDEbM7mcWLJHEg4P/mnLsEHR0pSr2MSTz4m2pvKgaGbd1h3sMaN/RFJrU39f0UQYEWY2lOGC4v3AO0hWj33DoOeCUdYwIuJKBvV1RMSnyra7SO6FYTZuDpg/lXxO3L/mOY4/aF7FppzhRj3lc6K1ub/ZanZ6jj2me+iqTT5VgyIifgf8TtKKiLhgnMpk1lBtzXkWz23nW9c/wvk3PlqxWai7t5d8TuTTJTwGa8rlmFL2mjntSVDMd1DYJFTrENdLJf2TpKUAkpZIev0YlsusoV6832wgWdNpzeaunZ7vLhRpySe/PpVqFDkNbE7qr1G438Emn1qD4kKgG3hp+ng18C9jUiKzCeCf33gY56cLBa7ZtH2n58tHRFXqo2jK5wYExcK0Y3qvWQ4Km3xqnUdxYEScKeltABHRKQ/Stgyb0pLnoD2mAfB0pRpFb39QVB71pAFNT6ceuRfHHzSvb10qs8mk1qDoljSFdCUKSQdSdktUsywqDU99ukKNYscwTU9NOdFW1pk9rbWJ/eZOHZuCmo2xWoPiM8BVwCJJPwCOB84eozKZTQhtzXnmTm1hzebKTU+tpRpFhaTI5zSg6anVw19tEqt1mfFfS7oNeAnJEkQfjoid1lsyy5qFs9p4elPlzuzmfKmPYufX7RQUQ8zwNpsMal1m/BfAD4FlEbFtuOPNsmKvmVN4fP3OP/LD9VGUNz3lNHaLtZmNh1o/5nwReDlwv6TLJJ0uycM3LPP2mjWFNUPUKPqDYufXldcoWpvyXqDPJrWagiIifhsRHwAOAL4DvAUY9R3uzCa6hTPb2LIjualTuZ7e8s7syn0UzfkcTYNmaJtNRjX/BKejnv6CZFmPo4HvjlWhzCaKhbOmAPDws1sH7B9Yo+gPilLtorT0eFtz3v0TNunV9BMs6cfASuBE4Osk8yo+OJYFM5sIjl48m5lTmvnAD24fMEx2xxBNT6WAaOoLityQS5WbTRa1/gRfQBIO74+I6yKi+g2VzTJi4cwpfP+9x7Jmcxe/uveZvv0DOrPLkqIUFLkBNQoPjbXJrdbhscslHSbp+UBb2f6Lx6xkZhPEYXvPIJ8TG7d19+3rLhRpze+8hEdeg2sUbnqyya/W4bGfBk4Ank+yLPjrgN8BDgrLPEnMbm9mQ+fAoKjW9JQvb3rKOyhscqv1J/h04CTgmYh4N3AEyW1JzXYLs9pb2FQeFEPMoxgcFPOntTJ3mpcWt8mt1iU8uiKiKKkgaQbJ0NhFw73ILCtmtzezYVDTU6W1nvK53IDvXzzjCM+hsEmv1qC4VdIs4D+B24CtJPexNtstzG5v4Yn1nX2Ph1pmvNTKlE93uTZhWVBrUMwguSXp9SSLA86IiLvHqlBmE83s9hbufGoTAMViUChGxaanpkE1CrMsqDUoLiBZwuNrwIHAHZJuiIivjFnJzCaQ2VNb2NjZTUTQ3ZuMDm+u0PRUygev7WRZUuvw2Osk3UAyI/uVJLOzXwCMKCgkzQF+BCwGHgfeEhEbKxzXC9yTPnwyIt44kvczG63Z7c309AbbunvpLQbQvyJs5RqFg8Kyo9aZ2dcC/wOcCTwAHB0Rh4zifT8OXBsRS4Br08eVbI+II9Mvh4Q1TOme1xu3ddNdSGoU/X0U/ccNXsLDLAtqbUi9m+Se2YcBhwOHpWs/jdSp9K8V9V3gTaM4l9mYm92eBkVnNz1p01OlRQFLNQo3PVmW1Lp67N9GxCuA04D1wH8Bm0bxvntGxJp0+xlgzyGOa5O0QtLNkt5U7YSSzkmPXbF27dpRFM1sZ3OmNgOwoUKNotI8ikp3vTObrGqdmX0uSWf2i0n6FC4EbhzmNdcACyo89cnyBxERkmKI0+wXEaslHQD8RtI9EfFIpQMjYimwFKCjo2Oo85mNyKy0RrGps4fuWQODonzi9eBFAc2yoNZRT23Al4DbIqJQywsi4lVDPSfpT5IWRsQaSQsZ4t4WEbE6/f6opOuBFwEVg8JsLM1Jg2JAjaLSWk+DZmabZUGtTU9fjIg/1BoSNVgGvCvdfhfw88EHSJotqTXdngccD9xfp/c32yUzpjQjwabObnbU0PTkoLAsadSsoM8Br5b0EPCq9DGSOiSdnx5zKLBC0l3AdcDnIsJBYQ2Rz4lZU5q546lNbNuRfF6qZVFAsyyotempriJiPckig4P3rwDel27/HnjhOBfNbEjvOX5//v3qB7ln9Wag8jyKwcuMm2WB1xkwq9EHT1rCaUftzabO5P7ZLfnkhkSqUKPwqCfLEgeF2S44ZMH0vu2K98z2qCfLIAeF2S7Yf960vu3KiwKmfRReWtwyxEFhtgv2n9fet92criU+YFFAlTqz/atl2eGfZrNdsGhOf1BUuh9FqUbRlHeNwrLDQWG2C1qb8v3baWf2gOGxfbUMB4Vlh4PCbIT6+ihyHh5r2eagMNtFpQyoNOGuyRPuLIMaMuHObDJb/pFXcMND6/rCQBWGxzooLEscFGa7aMme01myZ/98inyl4bEOCssQNz2ZjZIn3FnWOSjMRkkV+ii8hIdliYPCbJQG1Cg86skyyEFhNkrlk7DdR2FZ5KAwGyXfuMiyzkFhNkqVblzkpifLEgeF2ShVume2l/CwLHFQmI1SpaYnLwpoWeKgMBulykt4+FfLsqMhP82SzpB0n6SipI4qx50s6QFJD0v6+HiW0axWlSbc+cZFliWN+thzL3AacMNQB0jKA98AXgc8H3ibpOePT/HMaldpwp1HPVmWNGStp4hYCQM7ASs4Bng4Ih5Nj70UOBW4f8wLaLYLKk64cx+FZchEbkjdG3iq7PGqdF9Fks6RtELSirVr14554cxKKt0z26OeLEvGrEYh6RpgQYWnPhkRP6/3+0XEUmApQEdHR9T7/GZD8TwKy7oxC4qIeNUoT7EaWFT2eJ90n9mEMuAOd+loJ/dRWJZM5KanW4ElkvaX1AK8FVjW4DKZ7WTgPIrSdweFZUejhse+WdIq4DjgCknL0/17SboSICIKwLnAcmAl8OOIuK8R5TWrZmDTU/Ir5aYny5JGjXq6HLi8wv6ngVPKHl8JXDmORTPbZeWj917xvHl88MSDOGD+tAaWyKy+fCtUs1EqrzzMaW/h719zcOMKYzYGJnIfhdmkUGkehVmWOCjMRqk8HJwTlkUOCrNRKg+HYVYbMJuUHBRmo1SqUTgjLKscFGajVOrMdv+EZZWDwmyU+moUDS6H2VhxUJiNklyjsIxzUJiNkqQkLJwTllEOCrM6yEl41Q7LKgeFWR3kJeQqhWWUg8KsDiRco7DMclCY1UFO8mQ7yywHhVkd5OQJd5ZdDgqzOkg6s50Ulk0OCrM6kGsUlmEOCrM6yOVco7DsclCY1UFOHhxr2eU73JnVQTI01lFh2eSgMKsDD421LGtI05OkMyTdJ6koqaPKcY9LukfSnZJWjGcZzXZFzhPuLMMaVaO4FzgN+E4Nx74yItaNcXnMRiUnEdHoUpiNjYYERUSsBFfXLTtyEoGTwrJpoo96CuDXkm6TdE61AyWdI2mFpBVr164dp+KZJZJ5FP7gY9k0ZjUKSdcACyo89cmI+HmNp3lZRKyWtAdwtaQ/RsQNlQ6MiKXAUoCOjg5/tLNxlZMoukZhGTVmQRERr6rDOVan35+VdDlwDFAxKMwaKZ8TFBtdCrOxMWGbniRNlTS9tA28hqQT3GzC8RIelmWNGh77ZkmrgOOAKyQtT/fvJenK9LA9gd9Jugu4BbgiIq5qRHnNhuNFAS3LGjXq6XLg8gr7nwZOSbcfBY4Y56KZjYhbnizLJmzTk9lkkty4qNGlMBsbDgqzOpDvcGcZ5qAwqwMv4WFZ5qAwq4NkmXEnhWWTg8KsDnzPbMsyB4VZHbiPwrLMQWFWB+6jsCxzUJjVgYfHWpY5KMzqwDOzLcscFGZ14GXGLcscFGZ1kM95cKxll4PCrA6SpqdGl8JsbDTqntlmmfLu4xfT0+tlAS2bHBRmdXDSoXs2ughmY8ZNT2ZmVpWDwszMqnJQmJlZVQ4KMzOrykFhZmZVOSjMzKwqB4WZmVXloDAzs6oUEY0uQ91JWgs8McKXzwPW1bE4k4GvOft2t+sFX/Ou2i8i5ld6IpNBMRqSVkRER6PLMZ58zdm3u10v+JrryU1PZmZWlYPCzMyqclDsbGmjC9AAvubs292uF3zNdeM+CjMzq8o1CjMzq8pBYWZmVe2WQSFpkaTrJN0v6T5JH65wjCR9VdLDku6WdFQjyloPNV7vO9LrvEfS7yUd0Yiy1kst11x27NGSCpJOH88y1lut1yzpBEl3psf8drzLWU81/mzPlPQLSXelx7y7EWWtF0ltkm4pu55/rnBMq6QfpX+//iBp8ajeNCJ2uy9gIXBUuj0deBB4/qBjTgF+BQh4CfCHRpd7jK/3pcDsdPt1k/l6a73m9Lk88BvgSuD0Rpd7HP6fZwH3A/umj/dodLnH4Zr/Efh8uj0f2AC0NLrso7hmAdPS7WbgD8BLBh3zAeDb6fZbgR+N5j13yxpFRKyJiNvT7S3ASmDvQYedClwciZuBWZIWjnNR66KW642I30fExvThzcA+41vK+qrx/xjgg8B/A8+OY/HGRI3X/HbgpxHxZHrcpL7uGq85gOmSBEwjCYrCuBa0jtK/SVvTh83p1+BRSacC3023LwNOSq9/RHbLoCiXVsleRJLK5fYGnip7vIrKf2gmlSrXW+69JLWpTBjqmiXtDbwZ+FYDijWmqvw/Pw+YLel6SbdJOmvcCzdGqlzz14FDgaeBe4APR0RxfEtXX5Lyku4k+YBzdUQM+fcrIgrAZmDuSN+vaaQvzAJJ00g+TX4kIp5rdHnGWi3XK+mVJEHxsvEs21gZ5pq/DHwsIoqj+LA14QxzzU3Ai4GTgCnATZJujogHx7mYdTXMNb8WuBM4ETgQuFrSjZP5dz4ieoEjJc0CLpd0WETcO1bvt9vWKCQ1k/xg/SAiflrhkNXAorLH+6T7JqUarhdJhwPnA6dGxPrxLN9YqOGaO4BLJT0OnA58U9Kbxq+E9VfDNa8ClkfEtohYB9wATPaBC8Nd87tJmtsiIh4GHgMOGc8yjpWI2ARcB5w86Km+v1+SmoCZwIh/p3fLoEjb6i4AVkbEl4Y4bBlwVjr66SXA5ohYM26FrKNarlfSvsBPgXdO9k+XUNs1R8T+EbE4IhaTtON+ICJ+Nn6lrK8af65/DrxMUpOkduBYknb9SanGa36SpAaFpD2Bg4FHx6eE9SdpflqTQNIU4NXAHwcdtgx4V7p9OvCbSHu2R2J3bXo6HngncE/azgfJyIh9ASLi2ySjYE4BHgY6ST6VTFa1XO+nSNowv5k2wxRicq+8Wcs1Z82w1xwRKyVdBdwNFIHzx7LJYhzU8v/8f4GLJN1DMmLoY2ltarJaCHxXUp7kw/6PI+KXks4DVkTEMpLw/J6kh0k67986mjf0Eh5mZlbVbtn0ZGZmtXNQmJlZVQ4KMzOrykFhZmZVOSjMLPMknZEuoFeUNORoPkkXSnpW0r2D9n9B0h/ThTMvLw1PTZ87XNJN6fnvSRfta5d0Rfqa+yR9ruz4syWtTRdmvFPS+8qe+7yke9OvM8v2S9JnJT0oaaWkDw0qX80LW0r6cHr++yR9ZLjjwUFhNiKSZkn6QLq9l6TLGl0mSyhZHfeiQbvvBU4jmWBYzUXsPHkN4GrgsIg4nGThwU+k79UEfB94f0S8ADgB6Elf88WIOIRkWZHjJb2u7Hw/iogj06/z03P9OXAUcCTJ/Jb/LWlGevzZJBPoDomIQ4FLy643D3we+PUw14akw4D/BRxDMtHy9ZIOGu51DgqzkZlFskInEfF0REzqJcqzLiJWRsQDNRx3A8m8g8H7f52umQQDF818DXB3RNyVHrc+InojojMirkv3dQO3M/xCm88HboiIQkRsI5nrUgqtvwbOK61RNWgxx4oLW0r6qKRb01pQaSnyQ0lWhu5Mr+e3JAFalYPCbGQ+BxyYNh38pNRUkTYr/EzS1ZIel3SupL+TdIekmyXNSY87UNJVShbmu1HSIen+M9JmgbskDffp1xrjPfQvmvk8ICQtl3S7pH8YfHDaTPUG4Nqy3X+R/gG/TFJpqaC7gJPTZqt5wCvpX0boQOBMSSsk/UrSkvTcFRe2lPQaYAlJzeFI4MWSXkFSs3q5pLnpzPxTGLhUUUW768xss9H6OElTxJFKVi39Zdlzh5E0N7SRzOz/WES8SNJ/AGeRLEa4lKS54iFJxwLfJFm07lPAayNidXk7uA1P0h+AVpKlxOeUzdT+WEQsr9N7fJJkifIfpLuaSBbQPJpkBYdrJd0WEdemxzcBlwBfjYjSsiG/AC6JiB2S/opkOfATI+LXko4Gfg+sBW4CetPXtAJdEdEh6TTgQuDlDL2w5WvSrzvSx9OAJRFxg6RSM9U2ksUSexmGg8Ks/q5L742wRdJmkj8MkCxxfbiSlU5fCvyk7Je7Nf3+PyTLTfyYZO0tq1FEHAtJHwVwdkScXc/zSzobeD1wUtm6SatImovWpcdcSdLPUKo9LAUeiogvl5WzfHG+84H/V/bcZ4HPpuf6IUl/SOl9Sj8PlwP/lW6XFrYEmAecIqlAslTJv0XEdwZfR0RcQLLEB5L+NT13VW56Mqu/HWXbxbLHRZIPZzlgU1ln5pFpByUR8X7gn0iaA26TNOJ7CFj9SDoZ+AfgjRHRWfbUcuCFaXNRE/BnJHcQRNK/kKza+pFB5yq/AdobSRdlVHKPibnp9uHA4fR3UP+MpCmK9D0ehKoLWy4H3pN+KEHS3pL2SLdL3/cl6Z/44XDX76AwG5ktJLfe3GXpfRAek3QG9A19PCLdPjAi/hARnyJpfhi2/diGJ+nNklYBxwFXSFqe7t8rrQWUjruEpMnnYEmrJL03ferrJP/fV6f9Ut8GiOSukF8CbiVpxrk9Iq6QtA/wSZIO6ts1cBjsh9KhqXcBHyIZ0QTJnepulHQ/SU3kL8s60D9H0q9xD/BvQN+Q2koi4tckAXBT+prL6P95/e/0PX4B/E26VHn1fz8vCmg2MmnTwOEknwgPjYjD0uaJjog4Nz3m8fTxuvLnJO1P0gG5kOQPxKURcZ6kn5J0Qoqk+eIjo1ke2qweHBRmZlaVm57MzKwqB4WZmVXloDAzs6ocFGZmVpWDwszMqnJQmJlZVQ4KMzOr6v8DRNjn4Jg9k2MAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "times = np.linspace(start_time, start_time+duration, 256)\n", + "plt.plot(times,waveforms[0]['signal']['L1'])\n", + "plt.title('L1')\n", + "plt.xlabel('times')\n", + "plt.ylabel('waveform')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'waveform')" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(times,whitened_signal_td_array[1][1])\n", + "plt.title('L1')\n", + "plt.xlabel('times')\n", + "plt.ylabel('waveform')" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "import h5py\n", + "\n", + "f = h5py.File('data_0.h5py','r')\n", + "name_list=[]\n", + "#shape_list=[]\n", + "#type_list=[]\n", + "data_set_list=[]\n", + "\n", + "for name in f:\n", + " name_list.append(name)\n", + " #shape_list.append(f2[f'{name}'].shape)\n", + " #type_list.append(f2[f'{name}'].dtype)\n", + " data_set_list.append(f[f'{name}'])\n", + " #print(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "x_data_sum = np.zeros((4,7))" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 5.75000000e+01, 5.75000000e+01, 2.23622810e+03,\n", + " 2.50000000e-01, 6.08466421e+00, 5.61082165e+00,\n", + " -6.60205630e-02],\n", + " [ 5.75000000e+01, 5.75000000e+01, 1.89683491e+03,\n", + " 2.50000000e-01, 8.08406686e-01, 1.81307954e+00,\n", + " 6.08042098e-01],\n", + " [ 5.75000000e+01, 5.75000000e+01, 2.87428498e+03,\n", + " 2.50000000e-01, 2.17605961e+00, 5.21336446e+00,\n", + " -9.46771794e-01],\n", + " [ 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00]])" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "for i in range(3):\n", + " x_data_sum[i] = [57.5,57.5,distances[i],0.25,locations[2][i],locations[0][i],locations[1][i]]\n", + "x_data_sum" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "for i in range(num_samples):\n", + " \n", + " with h5py.File(f'data_202012040{i}.h5py','w') as f1:\n", + " \n", + " for k in range(len(name_list)):\n", + " d = f1.create_dataset(name_list[k],data=data_set_list[k])\n", + " x_data_list = [57.5,57.5,distances[i],0.25,locations[2][i],locations[0][i],locations[1][i]]\n", + " x_data=np.array(x_data_list)\n", + " \n", + " del f1['x_data']\n", + " del f1['y_data_noisefree']\n", + " \n", + " d1 = f1.create_dataset('x_data',data = x_data)\n", + " d2 = f1.create_dataset('y_data_noisefree',data = whitened_signal_td_array[i])\n" + ] + } + ], + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} -- GitLab