diff --git a/AUTHORS b/AUTHORS new file mode 100644 index 0000000..be2386b --- /dev/null +++ b/AUTHORS @@ -0,0 +1,3 @@ +Theodore Kisner +Giuseppe Puglisi +Reijo Keskitalo diff --git a/examples/introduction.html b/examples/introduction.html deleted file mode 100644 index 9da84f0..0000000 --- a/examples/introduction.html +++ /dev/null @@ -1,15881 +0,0 @@ - - - - - -introduction - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/examples/introduction.ipynb b/examples/introduction.ipynb index 1218e67..597fcaa 100644 --- a/examples/introduction.ipynb +++ b/examples/introduction.ipynb @@ -8,12 +8,47 @@ "source": [ "# Introduction\n", "\n", - "This is a basic example of using TOAST interactively for LiteBIRD simulations. This uses an extra package to help displaying things in the notebook. You can install that with `pip install wurlitzer` and restart this notebook kernel." + "This is a basic example of using TOAST interactively for LiteBIRD simulations. You can install the two packages with:" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# ! pip install --pre toast\n", + "# ! pip install https://github.com/hpc4cmb/litebirdtask/archive/main.zip" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "toc-hr-collapsed": false + }, + "source": [ + "This notebook uses additional packages that can be installed with pip or conda depending on the tool you are using to manage your environment:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#! pip install wurlitzer ipywidgets plotly plotly-resampler" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now import our modules:" + ] + }, + { + "cell_type": "code", + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -21,6 +56,7 @@ "import sys\n", "import os\n", "from datetime import datetime\n", + "import tempfile\n", "\n", "# External modules\n", "import numpy as np\n", @@ -32,12 +68,12 @@ "\n", "import toast\n", "import toast.ops\n", - "from toast import schedule_sim_satellite as schedulesim\n", - "from toast import pixels_io as pio\n", + "from toast import pixels_io_healpix as pio\n", + "import toast.widgets\n", "\n", "import litebirdtask as lbt\n", "from litebirdtask import vis as lbtv\n", - "from litebirdtask import ops as lbtops\n", + "from litebirdtask import ops\n", "\n", "\n", "# Capture C++ output in the jupyter cells\n", @@ -51,687 +87,388 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Instrument Data\n", + "# Data Simulation\n", "\n", - "Specify the location of the instrument / hardware file you downloaded from the wiki (See https://wiki.kek.jp/pages/viewpage.action?pageId=150667506)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "hwfile = \"/home/kisner/git/litebird/litebird_model_2021-02-15T22:12:51.toml.gz\"" + "We start by creating a simulated LiteBIRD observing campaign with a scan strategy based on the instrument model and a few other parameters. We then simulate detector timestream components to produce a realistic data set for analysis." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Load the Hardware Model\n", + "## Instrument Model\n", "\n", - "This loads the full instrument model:" + "The rest of the notebook requires a local copy of the IMO. This can be downloaded from the wiki (for example). This file contains not only instrument parameters, but also default scanning parameters." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "hw = lbt.Hardware(path=hwfile)" + "imo_file = \"/home/kisner/data/litebird/IMoV2-14June.json\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Select Detectors\n", + "## Simulated Observing\n", + "\n", + "Next we are going to run a LiteBIRD scanning simulation. We start with an empty TOAST data container. For this notebook we are not using MPI, but MPI is supported both in standalone workflow scripts as well as notebooks using the MPI backend to ipyparallel.\n", "\n", - "The file you download from the wiki has **all** detectors. For this example, we will select just a few of them." + "The `SimObserve` operator here selects detectors based on regular expressions matching the telescope, channel, and wafer names. The length of a science observation is a free parameter, along with the number of observations to simulate (up to the mission length). The gap length is obtained from the duty cycle in the IMO, along with all the scanning parameters." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "lfhw = hw.select(\n", - " match={\n", - " \"wafer\": [\"L00\",],\n", - " \"band\": \".*040\",\n", - " \"pixel\": \"00.\"\n", - " }\n", - ")" + "# Starting with empty Data container\n", + "data = toast.Data()" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "We can see which detectors were selected:" + "# Get help about an operator\n", + "?ops.SimObserve" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[97msoftware : \u001b[91m 3 objects\u001b[0m\n", - " \u001b[94mlitebirdms, litebirdtask, toast\u001b[0m\n", - "\u001b[97mpixels : \u001b[91m 2 objects\u001b[0m\n", - " \u001b[94mLP1, LP2\u001b[0m\n", - "\u001b[97mbands : \u001b[91m 6 objects\u001b[0m\n", - " \u001b[94mL2-068, L2-050, L1-078, L1-040, L2-089, L1-060\u001b[0m\n", - "\u001b[97mtelescopes : \u001b[91m 1 objects\u001b[0m\n", - " \u001b[94mLFT\u001b[0m\n", - "\u001b[97mwafers : \u001b[91m 1 objects\u001b[0m\n", - " \u001b[94mL00\u001b[0m\n", - "\u001b[97mdetectors : \u001b[91m 12 objects\u001b[0m\n", - " \u001b[94mL00_003_QA_040T, L00_003_QA_040B, L00_004_QB_040T, L00_004_QB_040B, \u001b[0m\n", - " \u001b[94mL00_005_UA_040T, L00_005_UA_040B, L00_006_UA_040T, L00_006_UA_040B, \u001b[0m\n", - " \u001b[94mL00_007_UB_040T, L00_007_UB_040B, L00_008_UA_040T, L00_008_UA_040B\u001b[0m\n" - ] - } - ], + "outputs": [], "source": [ - "lbtv.summary_text(lfhw)" + "# Simulate\n", + "sim_obs = ops.SimObserve(\n", + " imo_file=imo_file,\n", + " select_telescope=\"LFT\",\n", + " select_channel=\"L1-040\",\n", + " select_wafer=None,\n", + " observation_time=60.0 * u.minute,\n", + " num_observation=24,\n", + " detset_key=\"pixel\",\n", + ")\n", + "sim_obs.apply(data)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Observing Schedule\n", + "## Pointing Model\n", "\n", - "Before running the simulation we need to create an \"observing schedule\". This is a simple model of stable science scans separated by optional \"gaps\". For this example we will make contiguous scans with no gaps. Here we make a schedule for 1 day of observing, with one-hour stable science scans:" + "Our pointing model consists of 3 pieces. The first is the detector pointing operator which translates boresight quaternions to the detector frame, with the Z-axis of the detector frame pointed at the detector line of sight and the X-axis of the detector frame aligned with the polarization sensitive direction. The second piece is an operator which computes the pixel indices given a detector's pointing on the sky. The final piece is an operator which computes the Stokes weights for each detector sample. In this example we are using default operators in TOAST, but could implement other operators specific to LiteBIRD (for example a more detailed HWP response). We use a low resolution pixelization for this example." ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "schedule = schedulesim.create_satellite_schedule(\n", - " prefix=\"LB_\",\n", - " mission_start=datetime.fromisoformat(\"2030-07-07T07:07:07+00:00\"),\n", - " observation_time=60 * u.minute,\n", - " gap_time=0 * u.minute,\n", - " num_observations=24, # 1 day x 24 obs per day\n", - " prec_period=3.2058 * u.hour, # From IMOv1 wiki page\n", - " spin_period=20 * u.minute, # From IMOv1 wiki, 0.05 RPM = 20 minutes\n", + "det_pntg = toast.ops.PointingDetectorSimple()\n", + "\n", + "det_pixels = toast.ops.PixelsHealpix(\n", + " nest=True,\n", + " nside=128,\n", + " detector_pointing=det_pntg,\n", + ")\n", + "\n", + "det_weights = toast.ops.StokesWeights(\n", + " mode=\"IQU\",\n", + " detector_pointing=det_pntg,\n", + " hwp_angle=sim_obs.hwp_angle,\n", ")" ] }, { - "cell_type": "code", - "execution_count": 7, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " \n", - " ... \n", - " \n", - " \n", - ">\n" - ] - } - ], "source": [ - "print(schedule)" + "## Default Noise Model\n", + "\n", + "We will estimate the noise below, but we can also create a default noise model based purely on nominal detector values." ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "We can also write / read this schedule to disk." + "default_model = toast.ops.DefaultNoiseModel()\n", + "default_model.apply(data)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Simulate the Scanning\n", + "## Simulated Timestream Components\n", "\n", - "Next we are going to run a LiteBIRD scanning simulation. We start with an empty TOAST data container:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "data = toast.Data()\n", - "print(data)" + "We can simulate a variety of detector data components." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Now we will create a LiteBIRD scanning \"Operator\" and apply it to the data. We can always see the help for an operator before we use it:" + "### Dipole\n", + "\n", + "This will simulate the solar plus orbital dipole, but the orbit is not simulated yet within the `LitebirdSite` class, and so this will only include the motion of the Earth." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# This will pop up a help window\n", - "#?lbtops.SimScan" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " # The hardware model\n", - " hwp_angle = hwp_angle # Observation shared key for HWP angle\n", - " hwp_rpm = 46.0 # The rate (in RPM) of the HWP rotation\n", - " hwp_step = None # For stepped HWP, the angle of each step\n", - " hwp_step_time = None # For stepped HWP, the time between steps\n", - " name = SimScan # The 'name' of this class instance\n", - " position = position # Observation shared key for position\n", - " prec_angle = 65.0 deg # The opening angle of the spin axis from the precession axis\n", - " schedule = \n", - " \n", - " ... \n", - " \n", - " \n", - "> # Instance of a SatelliteSchedule\n", - " shared_flags = flags # Observation shared key for common flags\n", - " spin_angle = 30.0 deg # The opening angle of the boresight from the spin axis\n", - " telescope = , focalplane = > # This must be an instance of a Telescope\n", - " times = times # Observation shared key for timestamps\n", - " velocity = velocity # Observation shared key for velocity\n", - ">\n", - "TOAST INFO: Focalplane has 12 detectors that span 20.031 degrees and are sampled at 19.0 Hz.\n" - ] - } - ], - "source": [ - "# Create the operator\n", - "\n", - "sim_scan = lbtops.SimScan(\n", - " hardware=lfhw,\n", - " schedule=schedule,\n", - " hwp_angle=\"hwp_angle\",\n", - " hwp_rpm=46.0 # for LFT from IMOv1\n", + "sim_dipole = toast.ops.SimDipole(\n", + " freq=40.0 * u.GHz,\n", + " mode=\"total\",\n", ")\n", - "\n", - "# Print it to see all the current options. You can change them anytime-\n", - "# not just in the constructor.\n", - "print(sim_scan)" + "sim_dipole.apply(data)" ] }, { - "cell_type": "code", - "execution_count": 11, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kisner/software/cmbenv/cmbenv_python/lib/python3.9/site-packages/erfa/core.py:154: ErfaWarning: ERFA function \"utctai\" yielded 1 of \"dubious year (Note 3)\"\n", - " warnings.warn('ERFA function \"{}\" yielded {}'.format(func_name, wmsg),\n", - "/home/kisner/software/cmbenv/cmbenv_python/lib/python3.9/site-packages/erfa/core.py:154: ErfaWarning: ERFA function \"taiutc\" yielded 1 of \"dubious year (Note 4)\"\n", - " warnings.warn('ERFA function \"{}\" yielded {}'.format(func_name, wmsg),\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - ", focalplane = >\n", - " 68400 total samples (68400 local)\n", - " shared: \n", - " detdata: \n", - " intervals: \n", - ">\n" - ] - } - ], "source": [ - "# Apply it to simulate the scanning\n", - "sim_scan.apply(data)\n", + "### Fake Sky\n", "\n", - "# Print just the first observation, since there are many\n", - "print(data.obs[0])" + "In order to avoid downloading a signal map in this notebook, we will just generate a fake synthetic sky. This is just for visualization and has no physical meaning." ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "### Memory Use\n", + "lmax = 2 * det_pixels.nside\n", + "cl = np.zeros(4 * (lmax + 1)).reshape([4, -1])\n", + "cl[0, :] = 1.0e-9 * np.ones(lmax + 1)\n", + "cl[1, :] = 1.0e-10 * np.ones(lmax + 1)\n", + "cl[2, :] = 1.0e-11 * np.ones(lmax + 1)\n", + "fake_I, fake_Q, fake_U = hp.synfast(\n", + " cl,\n", + " det_pixels.nside,\n", + " pol=True,\n", + " lmax=lmax,\n", + " fwhm=np.radians(3.0),\n", + " verbose=False,\n", + ")\n", + "\n", + "fake_sky_file = \"fake_input_sky.fits\"\n", + "hp.write_map(fake_sky_file, [fake_I, fake_Q, fake_U])\n", "\n", - "We can always see how much memory our data container is using with a small helper operator:" + "hp.mollview(fake_I, title=\"Fake Sky I\", cmap=\"inferno\")\n", + "hp.mollview(fake_Q, title=\"Fake Sky Q\", cmap=\"inferno\")\n", + "hp.mollview(fake_U, title=\"Fake Sky U\", cmap=\"inferno\")\n" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "TOAST INFO: : Total timestream memory use = 0.148 GB\n", - "TOAST INFO: : Memory usage (whole node)\n", - " total : 62.555 GB\n", - " available : 53.894 GB\n", - " percent : 13.800 % \n", - " used : 7.938 GB\n", - " free : 49.247 GB\n", - " active : 2.194 GB\n", - " inactive : 9.930 GB\n", - " buffers : 362.027 MB\n", - " cached : 5.017 GB\n", - " shared : 226.332 MB\n", - " slab : 485.727 MB\n", - "\n" - ] - }, - { - "data": { - "text/plain": [ - "159235200" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "mem_count = toast.ops.MemoryCounter()\n", - "mem_count.apply(data)" + "# Now scan this into a map\n", + "sim_map_scan = toast.ops.ScanHealpixMap(\n", + " file=fake_sky_file,\n", + " pixel_pointing=det_pixels,\n", + " stokes_weights=det_weights,\n", + ")\n", + "sim_map_scan.apply(data)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Observation Data\n", + "### Instrumental Noise\n", "\n", - "In the last cell you can see that the `Observation` has several \"shared\" data fields containing the pointing information and some other empty types of data \"detdata\" and \"intervals\". We can just print these like a numpy array:" + "For this small example, we are just simulating per-detector 1/f noise from the nominal noise model, but we could also simulate correlated noise by creating a suitable `Noise` object for each observation that had a mixing matrix describing the correlations." ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], + "outputs": [], "source": [ - "print(data.obs[0].shared[\"times\"])" + "sim_noise = toast.ops.SimNoise(\n", + " noise_model=default_model.noise_model,\n", + ")\n", + "sim_noise.apply(data)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "You can see that the \"shared\" data buffers are a special kind of array that (if MPI is being used) have only a single copy on each compute node. You can access individual elements with normal slice notation, or you can get a numpy array view by accessing the `.data` attribute. For example we can plot them:" + "### Saving Data\n", + "\n", + "If we want to save this simulated data for later we can do that now. Here we use the TOAST native HDF5 format with FLAC compression for the detector signal and gzip for the flags." ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "# Plot HWP angle vs time for observation 7\n", - "times = data.obs[7].shared[\"times\"]\n", - "hwp = data.obs[7].shared[\"hwp_angle\"]\n", + "hdf5_volume = \"data\"\n", "\n", - "fig = plt.figure()\n", - "ax = fig.add_subplot(111)\n", - "\n", - "ax.plot(times.data[:100], hwp.data[:100])\n", + "save_hdf5 = toast.ops.SaveHDF5(\n", + " volume=hdf5_volume,\n", + " detdata=[\n", + " (sim_obs.det_data, {\"type\": \"flac\"}),\n", + " (sim_obs.det_flags, {\"type\": \"gzip\"}),\n", + " ]\n", + ")\n", "\n", - "plt.show()" + "save_hdf5.apply(data)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The `Observation` class also gives us access to the focalplane properties for this observation:" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - ", focalplane = >\n" - ] - } - ], - "source": [ - "# The telescope for this observation\n", - "print(data.obs[0].telescope)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "# The focalplane\n", - "print(data.obs[0].telescope.focalplane)" + "# Data Exploration\n", + "\n", + "You can directly access / modify / plot data stored within the TOAST containers. Each `Observation` is independent, so for this exercise we can look at just the first observation." ] }, { "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " name dtype shape unit class \n", - "-------------- ------- ----- -------- --------\n", - " name bytes16 Column\n", - " quat float64 (4,) Column\n", - " pol_leakage float64 Column\n", - " fwhm float64 arcmin Quantity\n", - " psd_fmin float64 Hz Quantity\n", - " psd_fknee float64 Hz Quantity\n", - " psd_alpha float64 Column\n", - " psd_net float64 K s(1/2) Quantity\n", - " bandcenter float64 GHz Quantity\n", - " bandwidth float64 GHz Quantity\n", - " pixel bytes4 Column\n", - " pixtype bytes4 Column\n", - " wafer bytes4 Column\n", - " telescope bytes4 Column\n", - " band bytes7 Column\n", - " pol bytes2 Column\n", - " handed bytes2 Column\n", - " orient bytes2 Column\n", - " uid uint64 Column\n", - " pol_angle float64 rad Quantity\n", - "pol_efficiency float64 Column\n", - "\n", - " name quat [4] pol_leakage fwhm psd_fmin ... handed orient uid pol_angle pol_efficiency\n", - " arcmin Hz ... rad \n", - "--------------- ------------------------------------------- ----------- ------ -------- ... ------ ------ ---------- --------------------- --------------\n", - "L00_003_QA_040T -0.023321400939351575 .. 0.9962580900024415 0.0 70.5 1e-05 ... A Q 2452023176 0.0006224346741062777 1.0\n", - "L00_003_QA_040B -0.0753372764283349 .. 0.7042416108154209 0.0 70.5 1e-05 ... A Q 1949258632 1.5714187614690027 1.0\n", - "L00_004_QB_040T -0.02332346188953628 .. 0.997276371551474 0.0 70.5 1e-05 ... B Q 2229894150 0.0 1.0\n", - "L00_004_QB_040B -0.06596871225134845 .. 0.7051808850411623 0.0 70.5 1e-05 ... B Q 3469767943 1.5707963267948966 1.0\n", - "L00_005_UA_040T -0.043246921111939986 .. 0.9222598191360736 0.0 70.5 1e-05 ... A U 3568971865 0.7847768888318001 1.0\n", - "L00_005_UA_040B -0.061314973484612026 .. 0.3822498292572019 0.0 70.5 1e-05 ... A U 3980116951 2.3555732156266966 1.0\n", - "L00_006_UA_040T -0.041140551545408396 .. 0.9201527581636282 0.0 70.5 1e-05 ... A U 64647515 0.787887566091844 1.0\n", - "L00_006_UA_040B -0.08073218768412954 .. 0.3801904516380561 0.0 70.5 1e-05 ... A U 381650307 2.3586838928867406 1.0\n", - "L00_007_UB_040T -0.03607207100796616 .. 0.9212123079860455 0.0 70.5 1e-05 ... B U 2726386366 0.7872631452799669 1.0\n", - "L00_007_UB_040B -0.06848982358858585 .. 0.3808667193749932 0.0 70.5 1e-05 ... B U 2591051207 2.358059472074863 1.0\n", - "L00_008_UA_040T -0.030992886592724245 .. 0.9221089433764212 0.0 70.5 1e-05 ... A U 2045003389 0.7866405456338799 1.0\n", - "L00_008_UA_040B -0.056233557328941336 .. 0.3814753802078734 0.0 70.5 1e-05 ... A U 1730883828 2.357436872428776 1.0\n" - ] - } - ], - "source": [ - "# The Table of detector properties\n", - "print(data.obs[0].telescope.focalplane.detector_data.info)\n", - "print(data.obs[0].telescope.focalplane.detector_data)" - ] - }, - { - "cell_type": "markdown", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "## Simulating Detector Signal\n", - "\n", - "When simulating detector data, we can accumulate signal from many sources, and also introduce systematics along the way." + "first_ob = data.obs[0]\n", + "print(first_ob)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Dipole\n", - "\n", - "For a simple sky signal component, we could start with a solar dipole." + "In the last cell you can see that the `Observation` has several \"shared\" data fields containing the pointing information and some other empty types of data \"detdata\" and \"intervals\". We can just print these like a numpy array:" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "sim_dipole = toast.ops.SimDipole(\n", - " freq=40.0 * u.GHz,\n", - " mode=\"solar\",\n", - ")\n", - "sim_dipole.apply(data)" + "print(first_ob.shared[\"times\"])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Now we can see what was created in the first observation:" + "You can see that the \"shared\" data buffers are a special kind of array that (if MPI is being used) have only a single copy on each compute node. You can access individual elements with normal slice notation, or you can get a numpy array view by accessing the `.data` attribute. For example we can plot them:" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - ", focalplane = >\n", - " 68400 total samples (68400 local)\n", - " shared: \n", - " detdata: \n", - " intervals: \n", - ">\n" - ] - } - ], + "outputs": [], "source": [ - "print(data.obs[0])" + "# Plot HWP angle vs time for the first observation\n", + "times = first_ob.shared[\"times\"]\n", + "hwp = first_ob.shared[\"hwp_angle\"]\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111)\n", + "\n", + "ax.plot(times.data[:100], hwp.data[:100])\n", + "\n", + "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Notice that the \"detdata\" attribute now has an item called \"signal\", which has 12 detector timestreams. The dipole timestream we simulated is in Kelvin, but let's work in\n", - "uK instead. We can modify the data in place:" + "The `detdata` attribute of an observation contains just the local data on each process, so you can read and write to these arrays. The named keys in this `detdata` dictionary allow us to access the data by detector name, detector index, or sample range:" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "for ob in data.obs:\n", - " ob.detdata[\"signal\"][:, :] *= 1e6" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Gain Drifts\n", - "\n", - "Now let us introduce a systematic effect- a small gain drift across all detectors. In this case we apply a thermal drift across our wafer. In order to plot the effect, we can copy the original signal to another detdata object." + "signal = first_ob.detdata[\"signal\"]" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "toast.ops.Copy(detdata=[(\"signal\", \"dipole\")]).apply(data)" + "print(signal[\"000_000_003_QA_040_B\"])" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "Now apply the gain drifts:" + "print(signal[[\"000_000_003_QA_040_B\", \"000_000_003_QA_040_T\"], 0:4])" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "gain_drifter = toast.ops.GainDrifter(\n", - " drift_mode=\"slow_drift\",\n", - " focalplane_group=\"wafer\",\n", - " #thermal_fluctuation_amplitude=0.2 * u.K,\n", - ")\n", - "gain_drifter.apply(data)" + "# The whole thing...\n", + "print(signal[:, :])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Plot the difference for one detector in one observation:" + "You can plot some detector data relative to the timestamps, for example:" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "times = data.obs[0].shared[\"times\"]\n", - "\n", "fig = plt.figure()\n", "ax = fig.add_subplot(111)\n", "\n", "ax.plot(\n", " times.data, \n", - " (\n", - " data.obs[0].detdata[\"signal\"][\"L00_003_QA_040T\"] -\n", - " data.obs[0].detdata[\"dipole\"][\"L00_003_QA_040T\"]\n", - " )\n", + " signal[\"000_000_003_QA_040_B\"],\n", + ")\n", + "\n", + "ax.plot(\n", + " times.data, \n", + " signal[\"000_000_003_QA_040_T\"],\n", ")\n", "\n", "plt.show()" @@ -741,237 +478,138 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Instrumental Noise\n", - "\n", - "Now we can simulate another component and accumulate that. Before simulating some instrumental noise, we need to create a \"noise model\" which describes the noise properties of the detectors. We could make this by hand with a mixing matrix that included correlations between detectors. For now, we will use a small operator to just create the noise model from the nominal focalplane properties:" + "The `Observation` class also gives us access to the focalplane properties for this observation:" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# Create an uncorrelated noise model from focalplane detector properties\n", - "\n", - "# (print help for this operator)\n", - "#?toast.ops.DefaultNoiseModel" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "default_model = toast.ops.DefaultNoiseModel(\n", - " noise_model=\"noise_model\" # The string where this will be stored in every observation\n", - ")\n", - "default_model.apply(data)\n", - "print(data.obs[0][\"noise_model\"])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next we create an operator that uses this noise model to simulate timestreams." + "# The telescope for this observation\n", + "print(first_ob.telescope)" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# (print help for this operator)\n", - "#?toast.ops.SimNoise" + "# The focalplane\n", + "print(first_ob.telescope.focalplane)" ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# Create it and specify the noise model to use and the detdata name of the output signal\n", - "\n", - "sim_noise = toast.ops.SimNoise(\n", - " noise_model=\"noise_model\",\n", - ")\n", - "sim_noise.apply(data)" + "# The Table of detector properties\n", + "print(first_ob.telescope.focalplane.detector_data.info)\n", + "print(first_ob.telescope.focalplane.detector_data)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We can now dig deeper into the simulated fake detector signal so far:" + "### Interactive Visualization\n", + "\n", + "The next line launches an interactive ipython widget. If you are running the whole notebook at once, comment out this line, since it will cause the kernel to run forever." ] }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], + "outputs": [], "source": [ - "print(data.obs[0].detdata[\"signal\"])" + "# w = toast.widgets.ObservationWidget(data.obs[0])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "This `DetectorData` object allows us to access the data by detector name, detector index, or sample range:" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [], - "source": [ - "signal = data.obs[0].detdata[\"signal\"]" + "# Data Reduction\n", + "\n", + "Now we consider the previous data set and analyze this. Here we use the data already simulated in memory, but could also load the data from disk. For this example, we do not perform focalplane reconstruction- that is a future exercise. We also do not demonstrate either HWP demodulation (which is supported in TOAST) or regression of HWP synchronous signal in the map-making (which is nearing completion)." ] }, { - "cell_type": "code", - "execution_count": 30, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 2111.77130739 2485.40849114 2080.20742994 ... -3340.70241997\n", - " -3814.85534656 -3072.73930521]\n" - ] - } - ], "source": [ - "print(signal[\"L00_003_QA_040T\"])" + "## Noise Estimation\n", + "\n", + "Here we estimate the noise assuming that the timestreams are noise dominated and fit those estimates to a 1/f model. In practice, since we have not removed the dipole, we expect this to show up as a large additional 1/f model." ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[2111.77130739 2485.40849114 2080.20742994 2480.62172629]\n", - " [1487.40595414 1747.48484882 2207.00412029 1940.22229438]]\n" - ] - } - ], + "outputs": [], "source": [ - "print(signal[[\"L00_003_QA_040T\", \"L00_004_QB_040T\"], 0:4])" + "noise_estim = toast.ops.NoiseEstim(\n", + " out_model=\"noise_est\",\n", + " lagmax=2048,\n", + " nbin_psd=64,\n", + " nsum=1,\n", + " naverage=128,\n", + ")\n", + "noise_estim.apply(data)" ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[ 2111.77130739 2485.40849114 2080.20742994 ... -3340.70241997\n", - " -3814.85534656 -3072.73930521]\n", - " [ 2052.72661948 2135.3628787 2430.52362894 ... -2331.57928895\n", - " -3170.48095192 -3137.04358523]\n", - " [ 1487.40595414 1747.48484882 2207.00412029 ... -2746.35789448\n", - " -3274.44519572 -3921.62124886]\n", - " ...\n", - " [ 2133.04262976 2309.22191522 2303.06327757 ... -2569.78667702\n", - " -3511.21860902 -2830.49916913]\n", - " [ 2384.74141634 2404.66532416 2324.583139 ... -2550.77529607\n", - " -2607.4726403 -3469.60001114]\n", - " [ 2601.69474335 1565.42706549 2175.81005473 ... -3774.86260802\n", - " -2983.33147303 -2349.57056954]]\n" - ] - } - ], + "outputs": [], "source": [ - "# The whole thing...\n", - "print(signal[:, :])" + "noise_fit = toast.ops.FitNoiseModel(\n", + " noise_model=noise_estim.out_model,\n", + " out_model=\"fit_noise\",\n", + " least_squares_ftol=None,\n", + " least_squares_xtol=1.0e-12,\n", + " least_squares_gtol=None,\n", + ")\n", + "noise_fit.apply(data)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The `detdata` attribute of an observation contains just the local data on each process, so you can read and write to these arrays. One can plot them using the shared timestamps as well:" + "Plot the noise estimate and fit for a couple detectors within one observation. Note the large 1/f due to the un-removed dipole." ] }, { "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "times = data.obs[0].shared[\"times\"]\n", - "\n", - "fig = plt.figure()\n", - "ax = fig.add_subplot(111)\n", - "\n", - "ax.plot(times.data, signal[\"L00_003_QA_040T\"])\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "## Other Operators\n", + "sim_noise = first_ob[default_model.noise_model]\n", + "est_noise = first_ob[noise_estim.out_model]\n", + "fit_noise = first_ob[noise_fit.out_model]\n", "\n", - "You can piece together many other operators to add different types of signal and systematics, etc. These can be covered in later notebooks." + "for idet in range(2):\n", + " det_name = first_ob.local_detectors[idet]\n", + " toast.vis.plot_noise_estim(\n", + " None,\n", + " est_noise.freq(det_name),\n", + " est_noise.psd(det_name),\n", + " fit_freq=fit_noise.freq(det_name),\n", + " fit_psd=fit_noise.psd(det_name),\n", + " true_net=sim_noise.NET(det_name),\n", + " true_freq=sim_noise.freq(det_name),\n", + " true_psd=sim_noise.psd(det_name),\n", + " semilog=False,\n", + " )" ] }, { @@ -980,158 +618,90 @@ "source": [ "## Map Making\n", "\n", - "Here we show a simple example of mapmaking. First, we need to create several operators that we will pass to the map maker (which will apply the operators internally). We begin with the pointing information. The low-level \"detector pointing\" operator maps telescope boresight quaternions to detector quaternions. The \"pointing matrix\" has 2 parts, the sky pixels and the Stokes weights:" + "Next we will make a basic map using a single regression template representing baseline offsets." ] }, { "cell_type": "code", - "execution_count": 34, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# The default detector pointing operator just takes the focalplane offset from\n", - "# the boresight and applies it to boresight pointing\n", - "\n", - "det_pointing = toast.ops.PointingDetectorSimple()\n", - "# Operator traits can be set in the constructor, or afterwards. The default \"names\"\n", - "# for the different objects in the Observation can be set per-experiment globally,\n", - "# and we can also get the traits from earlier operators in the workflow and use\n", - "# them in later ones:\n", - "det_pointing.boresight = sim_scan.boresight\n", - "\n", - "# This operator defines the sky pixels\n", - "pixels = toast.ops.PixelsHealpix(\n", - " nside=512,\n", - " detector_pointing=det_pointing\n", - ")\n", - "\n", - "# These are the Stokes weights. Notice we set some traits in the\n", - "# constructor- we could also set these aftwards if we wanted.\n", - "weights = toast.ops.StokesWeights(\n", - " mode=\"IQU\",\n", - " hwp_angle=sim_scan.hwp_angle,\n", - " detector_pointing=det_pointing\n", + "# Use a single Offset template (destriping baselines)\n", + "baselines = toast.templates.Offset(\n", + " noise_model=noise_fit.out_model,\n", + " step_time=1.0 * u.second,\n", ")" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "Next we need a \"binning\" operator that will be used during the template amplitude solving and also the final map binning. The mapmaker accepts different binning operators for these two steps, but here we use the same one.\n", - "\n", - "Here we demonstrate a useful technique: If you have a previous operator configured with particular traits (in this case the name of the noise model in the observations), you can access that and pass it to other operators." + "# Template matrix with these templates\n", + "tmatrix = toast.ops.TemplateMatrix(\n", + " templates=[baselines],\n", + ")" ] }, { "cell_type": "code", - "execution_count": 35, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# Set up binning operator for solving and final map. Again,\n", - "# this is just creating the operator, not actually doing\n", - "# anything yet.\n", + "# Binning operator\n", "binner = toast.ops.BinMap(\n", - " pixel_pointing=pixels,\n", - " stokes_weights=weights,\n", - " noise_model=default_model.noise_model,\n", + " pixel_pointing=det_pixels,\n", + " stokes_weights=det_weights,\n", + " noise_model=noise_fit.out_model,\n", ")" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we set up the templates we will use in our map making. In this case we will use a single template for offset amplitudes (destriping baselines). After configuring our templates, we add them to a template matrix operator:" - ] - }, { "cell_type": "code", - "execution_count": 36, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# Set up template matrix with just an offset template.\n", - "\n", - "tmpl = toast.templates.Offset(\n", - " times=sim_scan.times,\n", - " noise_model=default_model.noise_model,\n", - " step_time=5.0 * u.second,\n", - ")\n", - "tmatrix = toast.ops.TemplateMatrix(templates=[tmpl])" + "# Optionally save full detector pointing. This speeds up the mapmaking dramatically,\n", + "# but results in a 5x increase in memory.\n", + "binner.full_pointing = True" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "### Low Memory Use\n", + "out_dir = \"maps\"\n", + "if not os.path.isdir(out_dir):\n", + " os.makedirs(out_dir)\n", "\n", - "Finally we are ready to create our Mapmaking operator and run it. This will be **slow**, since by default we are not saving the pointing. So every iteration of the solver we are re-generating the pixel number and Stokes weights for every sample, for every detector. We are also doing this using a single process in this notebook." + "mapper = toast.ops.MapMaker(\n", + " binning=binner,\n", + " template_matrix=tmatrix,\n", + " solve_rcond_threshold=1e-3,\n", + " map_rcond_threshold=1e-3,\n", + " iter_min=40,\n", + " iter_max=100,\n", + " write_hits=True,\n", + " write_map=True,\n", + " write_binmap=True,\n", + " write_cov=True,\n", + " output_dir=out_dir,\n", + ")" ] }, { "cell_type": "code", - "execution_count": 37, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "TOAST INFO: MapMaker begin building flags for solver\n", - "TOAST INFO: MapMaker finished flag building in 0.01 s\n", - "TOAST INFO: MapMaker begin build of solver covariance\n", - "TOAST INFO: MapMaker finished build of solver covariance in 10.33 s\n", - "TOAST INFO: MapMaker Solver flags cut 0 / 19699200 = 0.00% of samples\n", - "TOAST INFO: MapMaker begin RHS calculation\n", - "TOAST INFO: MapMaker finished RHS calculation in 7.77 s\n", - "TOAST INFO: MapMaker begin PCG solver\n", - "TOAST INFO: MapMaker initial residual = 37630.60316637864, 7.62 s\n", - "TOAST INFO: MapMaker iteration 0, relative residual = 6.639905e-02, 8.20 s\n", - "TOAST INFO: MapMaker iteration 1, relative residual = 4.349527e-02, 8.17 s\n", - "TOAST INFO: MapMaker iteration 2, relative residual = 4.105895e-02, 7.93 s\n", - "TOAST INFO: MapMaker iteration 3, relative residual = 3.253614e-02, 7.67 s\n", - "TOAST INFO: MapMaker iteration 4, relative residual = 3.032933e-02, 11.31 s\n", - "TOAST INFO: MapMaker iteration 5, relative residual = 3.068060e-02, 8.07 s\n", - "TOAST INFO: MapMaker iteration 6, relative residual = 3.155900e-02, 8.43 s\n", - "TOAST INFO: MapMaker iteration 7, relative residual = 3.173728e-02, 7.97 s\n", - "TOAST INFO: MapMaker iteration 8, relative residual = 3.120212e-02, 8.33 s\n", - "TOAST INFO: MapMaker iteration 9, relative residual = 3.118039e-02, 7.94 s\n", - "TOAST INFO: MapMaker finished solver in 91.64 s\n", - "TOAST INFO: MapMaker begin build of final binning covariance\n", - "TOAST INFO: MapMaker finished build of final covariance in 8.33 s\n", - "TOAST INFO: MapMaker begin final map binning\n", - "TOAST INFO: MapMaker finished final binning in 3.97 s\n", - "TOAST INFO: Wrote ./mapmaker_hits.fits in 0.10 s\n", - "TOAST INFO: Wrote ./mapmaker_rcond.fits in 0.07 s\n", - "TOAST INFO: Wrote ./mapmaker_map.fits in 0.23 s\n", - "TOAST INFO: Wrote ./mapmaker_cov.fits in 0.57 s\n", - "TOAST INFO: MapMaker finished output write in 0.01 s\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "# Map maker set up\n", - "\n", - "# Where the maps should be written\n", - "output_dir = \".\"\n", - "\n", - "mapper = toast.ops.MapMaker(\n", - " name=\"mapmaker\", # This name will prefix all the output products.\n", - " det_data=\"signal\", # The name of the detector data we simulated\n", - " binning=binner,\n", - " template_matrix=tmatrix,\n", - " solve_rcond_threshold=1.0e-6,\n", - " map_rcond_threshold=1.0e-6,\n", - " iter_max=10,\n", - " output_dir=output_dir\n", - ")\n", - "\n", - "# Make the map\n", "mapper.apply(data)" ] }, @@ -1139,276 +709,58 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Note that because we have added a gain drift and not mitigated it, the solver did not converge. You can comment out the gain drift above and re-run to see how it converges. Now we can read our outputs and plot them. Note that our timestream has the dipole in it still, which we would normally use for calibration and remove. " + "Now plot the output maps and residual compared to the input fake sky:" ] }, { "cell_type": "code", - "execution_count": 38, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/kisner/software/cmbenv/cmbenv_aux/lib/python3.9/site-packages/healpy/fitsfunc.py:391: UserWarning: NSIDE = 512\n", - " warnings.warn(\"NSIDE = {0:d}\".format(nside))\n", - "/home/kisner/software/cmbenv/cmbenv_aux/lib/python3.9/site-packages/healpy/fitsfunc.py:400: UserWarning: ORDERING = NESTED in fits file\n", - " warnings.warn(\"ORDERING = {0:s} in fits file\".format(ordering))\n", - "/home/kisner/software/cmbenv/cmbenv_aux/lib/python3.9/site-packages/healpy/fitsfunc.py:428: UserWarning: INDXSCHM = IMPLICIT\n", - " warnings.warn(\"INDXSCHM = {0:s}\".format(schm))\n", - "/home/kisner/software/cmbenv/cmbenv_aux/lib/python3.9/site-packages/healpy/fitsfunc.py:486: UserWarning: Ordering converted to RING\n", - " warnings.warn(\"Ordering converted to RING\")\n", - "/home/kisner/software/cmbenv/cmbenv_aux/lib/python3.9/site-packages/healpy/projaxes.py:920: MatplotlibDeprecationWarning: You are modifying the state of a globally registered colormap. This has been deprecated since 3.3 and in 3.6, you will not be able to modify a registered colormap in-place. To remove this warning, you can make a copy of the colormap first. cmap = mpl.cm.get_cmap(\"viridis\").copy()\n", - " newcm.set_over(newcm(1.0))\n", - "/home/kisner/software/cmbenv/cmbenv_aux/lib/python3.9/site-packages/healpy/projaxes.py:921: MatplotlibDeprecationWarning: You are modifying the state of a globally registered colormap. This has been deprecated since 3.3 and in 3.6, you will not be able to modify a registered colormap in-place. To remove this warning, you can make a copy of the colormap first. cmap = mpl.cm.get_cmap(\"viridis\").copy()\n", - " newcm.set_under(bgcolor)\n", - "/home/kisner/software/cmbenv/cmbenv_aux/lib/python3.9/site-packages/healpy/projaxes.py:922: MatplotlibDeprecationWarning: You are modifying the state of a globally registered colormap. This has been deprecated since 3.3 and in 3.6, you will not be able to modify a registered colormap in-place. To remove this warning, you can make a copy of the colormap first. cmap = mpl.cm.get_cmap(\"viridis\").copy()\n", - " newcm.set_bad(badcolor)\n", - "/home/kisner/software/cmbenv/cmbenv_aux/lib/python3.9/site-packages/healpy/projaxes.py:202: MatplotlibDeprecationWarning: Passing parameters norm and vmin/vmax simultaneously is deprecated since 3.3 and will become an error two minor releases later. Please pass vmin/vmax directly to the norm when creating it.\n", - " aximg = self.imshow(\n", - "/home/kisner/software/cmbenv/cmbenv_aux/lib/python3.9/site-packages/healpy/fitsfunc.py:368: UserWarning: If you are not specifying the input dtype and using the default np.float64 dtype of read_map(), please consider that it will change in a future version to None as to keep the same dtype of the input file: please explicitly set the dtype if it is important to you.\n", - " warnings.warn(\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "mapfile_root = os.path.join(output_dir, mapper.name)\n", + "mapfile_root = os.path.join(mapper.output_dir, mapper.name)\n", "\n", "hits = hp.read_map(\n", " f\"{mapfile_root}_hits.fits\", \n", " dtype=np.int32\n", ")\n", - "hp.mollview(hits, min=0, max=500)\n", + "hp.mollview(hits, title=\"Solved Map Hits\", cmap=\"inferno\", min=0, max=1000)\n", "\n", "Imap, Qmap, Umap = hp.read_map(\n", " f\"{mapfile_root}_map.fits\", \n", " field=None\n", ")\n", - "hp.mollview(Imap, min=-0.0005, max=0.0005)\n", - "hp.mollview(Qmap, min=-0.0005, max=0.0005)\n", - "hp.mollview(Umap, min=-0.0005, max=0.0005)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Larger Memory Use and Faster\n", "\n", - "If we have enough memory, we can compute the pointing once and save it. Check how much memory we are using right now:" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "TOAST INFO: : Total timestream memory use = 0.595 GB\n", - "TOAST INFO: : Memory usage (whole node)\n", - " total : 62.555 GB\n", - " available : 53.220 GB\n", - " percent : 14.900 % \n", - " used : 8.613 GB\n", - " free : 48.570 GB\n", - " active : 2.196 GB\n", - " inactive : 10.610 GB\n", - " buffers : 363.148 MB\n", - " cached : 5.018 GB\n", - " shared : 225.656 MB\n", - " slab : 486.207 MB\n", - "\n" - ] - }, - { - "data": { - "text/plain": [ - "638582400" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Reset the counter first...\n", - "mem_count.total_bytes = 0\n", - "mem_count.apply(data)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "OK, now we can generate the pointing once for the whole dataset:" + "hit_pix = hits > 0\n", + "unhit_pix = np.logical_not(hit_pix)\n", + "Imap[unhit_pix] = hp.UNSEEN\n", + "Qmap[unhit_pix] = hp.UNSEEN\n", + "Umap[unhit_pix] = hp.UNSEEN\n", + "\n", + "I_range = 0.005\n", + "P_range = 0.0002\n", + "hp.mollview(Imap, title=\"Solved Map Stokes I\", cmap=\"inferno\", min=-I_range, max=I_range)\n", + "hp.mollview(Qmap, title=\"Solved Map Stokes Q\", cmap=\"inferno\", min=-P_range, max=P_range)\n", + "hp.mollview(Umap, title=\"Solved Map Stokes U\", cmap=\"inferno\", min=-P_range, max=P_range)" ] }, { "cell_type": "code", - "execution_count": 40, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "pixels.apply(data)\n", - "weights.apply(data)" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "TOAST INFO: : Total timestream memory use = 1.671 GB\n", - "TOAST INFO: : Memory usage (whole node)\n", - " total : 62.555 GB\n", - " available : 52.085 GB\n", - " percent : 16.700 % \n", - " used : 9.749 GB\n", - " free : 47.435 GB\n", - " active : 2.196 GB\n", - " inactive : 11.736 GB\n", - " buffers : 363.203 MB\n", - " cached : 5.016 GB\n", - " shared : 224.281 MB\n", - " shared : 225.047 MB (after GC)\n", - " slab : 486.000 MB\n", - "\n" - ] - }, - { - "data": { - "text/plain": [ - "1794268800" - ] - }, - "execution_count": 41, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Check memory use now\n", - "mem_count.total_bytes = 0\n", - "mem_count.apply(data)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now re-run the mapmaking and write the outputs to a different name:" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "TOAST INFO: MapMaker begin building flags for solver\n", - "TOAST INFO: MapMaker finished flag building in 0.01 s\n", - "TOAST INFO: MapMaker begin build of solver covariance\n", - "TOAST INFO: MapMaker finished build of solver covariance in 5.30 s\n", - "TOAST INFO: MapMaker Solver flags cut 0 / 19699200 = 0.00% of samples\n", - "TOAST INFO: MapMaker begin RHS calculation\n", - "TOAST INFO: MapMaker finished RHS calculation in 1.16 s\n", - "TOAST INFO: MapMaker begin PCG solver\n", - "TOAST INFO: MapMaker initial residual = 37630.60316637864, 1.51 s\n", - "TOAST INFO: MapMaker iteration 0, relative residual = 6.639905e-02, 1.35 s\n", - "TOAST INFO: MapMaker iteration 1, relative residual = 4.349527e-02, 1.22 s\n", - "TOAST INFO: MapMaker iteration 2, relative residual = 4.105895e-02, 1.35 s\n", - "TOAST INFO: MapMaker iteration 3, relative residual = 3.253614e-02, 1.09 s\n", - "TOAST INFO: MapMaker iteration 4, relative residual = 3.032933e-02, 1.03 s\n", - "TOAST INFO: MapMaker iteration 5, relative residual = 3.068060e-02, 1.22 s\n", - "TOAST INFO: MapMaker iteration 6, relative residual = 3.155900e-02, 1.26 s\n", - "TOAST INFO: MapMaker iteration 7, relative residual = 3.173728e-02, 1.01 s\n", - "TOAST INFO: MapMaker iteration 8, relative residual = 3.120212e-02, 1.03 s\n", - "TOAST INFO: MapMaker iteration 9, relative residual = 3.118039e-02, 1.02 s\n", - "TOAST INFO: MapMaker finished solver in 13.09 s\n", - "TOAST INFO: MapMaker begin build of final binning covariance\n", - "TOAST INFO: MapMaker finished build of final covariance in 3.52 s\n", - "TOAST INFO: MapMaker begin final map binning\n", - "TOAST INFO: MapMaker finished final binning in 0.60 s\n", - "TOAST INFO: Wrote ./example2_hits.fits in 0.07 s\n", - "TOAST INFO: Wrote ./example2_rcond.fits in 0.06 s\n", - "TOAST INFO: Wrote ./example2_map.fits in 0.20 s\n", - "TOAST INFO: Wrote ./example2_cov.fits in 0.50 s\n", - "TOAST INFO: MapMaker finished output write in 0.00 s\n" - ] - } - ], - "source": [ - "mapper.name = \"example2\"\n", - "mapper.apply(data)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "So here we see that it runs much faster." + "# Plot the residual\n", + "Idiff = Imap - fake_I\n", + "Qdiff = Qmap - fake_Q\n", + "Udiff = Umap - fake_U\n", + "Idiff[unhit_pix] = hp.UNSEEN\n", + "Qdiff[unhit_pix] = hp.UNSEEN\n", + "Udiff[unhit_pix] = hp.UNSEEN\n", + "\n", + "hp.mollview(Idiff, title=\"Solved Minus Input Stokes I\", cmap=\"inferno\", min=-I_range, max=I_range)\n", + "hp.mollview(Qdiff, title=\"Solved Minus Input Stokes Q\", cmap=\"inferno\", min=-P_range, max=P_range)\n", + "hp.mollview(Udiff, title=\"Solved Minus Input Stokes U\", cmap=\"inferno\", min=-P_range, max=P_range)" ] }, { @@ -1435,7 +787,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.5" + "version": "3.10.12" } }, "nbformat": 4, diff --git a/litebirdtask/instrument.py b/litebirdtask/instrument.py new file mode 100644 index 0000000..e3b3b3c --- /dev/null +++ b/litebirdtask/instrument.py @@ -0,0 +1,368 @@ +# Copyright (c) 2015-2023 by the parties listed in the AUTHORS file. +# All rights reserved. Use of this source code is governed by +# a BSD-style license that can be found in the LICENSE file. +"""Instrument Classes +""" + +import json +import os +import sys +from datetime import datetime, timezone, timedelta +import re + +import numpy as np + +import astropy.units as u +from astropy.table import QTable, Column +from toast.instrument import Focalplane, SpaceSite, Telescope +from toast.schedule import SatelliteSchedule, SatelliteScan +from toast.utils import Logger + + +class LitebirdSite(SpaceSite): + def __init__( + self, + name="LiteBIRD", + **kwargs, + ): + super().__init__( + name, + **kwargs, + ) + + def _position(self, times): + # Eventually we could insert simulated or real orbital dynamics + return super()._position(times) + + def _velocity(self, times): + # Eventually we could insert simulated or real orbital dynamics + return super()._velocity(times) + + +def load_imo( + path, + telescope=None, + channel=None, + wafer=None, + pixel=None, + detector=None, + wafer_obs=False, +): + """Load a subset of an Instrument Model. + + This function loads an IMO file and selects a subset of detectors. The resulting + detectors are grouped either by channel or wafer, and placed into a Telescope + instance suitable for creating Observations. + + Args: + path (str): The path to the IMO JSON file. + telescope (str): Only use detectors from this telescope. + channel (str): Only use this channel (frequency). The string is interpreted + as a regular expression. + wafer (str): Only use this wafer. The string is interpreted as a regular + expression. + pixel (str): Only use this pixel. The string is interpreted as a regular + expression. + detector (str): Only use this detector. The string is interpreted as a regular + expression. + wafer_obs (bool): If True, split detectors into observations according to + wafer. Default is to split by telescope-channel. + + Returns: + (tuple): A tuple containing the IMO scanning parameters and a list of + Telescope objects, each suitable for creating an Observation. + + """ + if telescope is None: + telescope = ".*" + if channel is None: + channel = ".*" + if wafer is None: + wafer = ".*" + if pixel is None: + pixel = ".*" + if detector is None: + detector = ".*" + tel_pat = re.compile(telescope) + chan_pat = re.compile(channel) + wafer_pat = re.compile(wafer) + pixel_pat = re.compile(pixel) + det_pat = re.compile(detector) + + # Load the full IMO + with open(path, "r") as f: + imo = json.load(f) + + # Extract all info from the "data_files". + tel_keys = [ + "channel_names", + "hwp_rpm", + "sampling_rate_hz", + "spin_boresight_angle_deg", + "boresight_rotangle_deg", + "spin_rotangle_deg", + ] + chan_keys = [ + "sampling_rate_hz", + "net_detector_ukrts", + "net_channel_ukrts", + "fknee_mhz", + "pol_sensitivity_detector_ukarcmin", + "pol_sensitivity_channel_ukarcmin", + "bandcenter_ghz", + "bandwidth_ghz", + "fwhm_arcmin", + "fmin_hz", + "alpha", + "psd_thermalbath_corr_ukcmb^2", + "psd_thermalbath_uncorr_ukcmb^2", + ] + scan_keys = [ + "spin_sun_angle_deg", + "precession_period_min", + "spin_rate_rpm", + "mission_duration_year", + "observation_duty_cycle", + "cosmic_ray_loss", + "margin", + "detector_yield", + ] + # Do one pass to extract all telescope and channel info + tel_data = dict() + scan_data = None + chan_data = dict() + chan_to_tel = dict() + for iobj, obj in enumerate(imo["data_files"]): + if obj["name"] == "instrument_info": + # This is a telescope + name = obj["metadata"]["name"] + props = {x: obj["metadata"][x] for x in tel_keys} + tel_data[name] = props + for ch in props["channel_names"]: + chan_to_tel[ch] = name + elif obj["name"] == "channel_info": + # This is a frequency + name = obj["metadata"]["channel"] + props = {x: obj["metadata"][x] for x in chan_keys} + chan_data[name] = props + elif obj["name"] == "scanning_parameters": + scan_data = {x: obj["metadata"][x] for x in scan_keys} + + # Now go through detectors + det_keys = [ + "wafer", + "pixel", + "pixtype", + "channel", + "squid", + "psd_dac_ukcmb^2", + "fwhm_arcmin", + "ellipticity", + "bandcenter_ghz", + "bandwidth_ghz", + "sampling_rate_hz", + "net_ukrts", + "pol_sensitivity_ukarcmin", + "fknee_mhz", + "fmin_hz", + "alpha", + "pol", + "orient", + "quat", + ] + obs_det_data = dict() + wafer_to_chan = dict() + for iobj, obj in enumerate(imo["data_files"]): + if obj["name"] == "detector_info": + # This is a detector + name = obj["metadata"]["name"] + if det_pat.match(name) is None: + continue + props = {x: obj["metadata"][x] for x in det_keys} + pixstr = f"{props['pixel']:03d}" + if pixel_pat.match(pixstr) is None: + continue + if wafer_pat.match(props["wafer"]) is None: + continue + if chan_pat.match(props["channel"]) is None: + continue + tel = chan_to_tel[props["channel"]] + if tel_pat.match(tel) is None: + continue + if props["wafer"] not in wafer_to_chan: + wafer_to_chan[props["wafer"]] = props["channel"] + if wafer_obs: + obs_key = props["wafer"] + else: + obs_key = props["channel"] + if obs_key not in obs_det_data: + obs_det_data[obs_key] = dict() + obs_det_data[obs_key][name] = props + + # Now that we have all properties for our selected detectors, build + # a table for each TOAST focalplane we will use. + + obs_tel = list() + + for oname, odets in obs_det_data.items(): + detlist = list(sorted(odets.keys())) + n_det = len(detlist) + + if n_det == 0: + msg = f"Telescope {oname} has no detectors" + raise RuntimeError(msg) + + # Now go through the detectors polarization / orientation and set the gamma + # and psi_pol angles... + + rate = odets[detlist[0]]["sampling_rate_hz"] * u.Hz + + if wafer_obs: + chan = wafer_to_chan[oname] + tel = chan_to_tel[chan] + tname = f"{tel}_{chan}_{oname}" + else: + chan = oname + tel = chan_to_tel[chan] + tname = f"{tel}_{chan}" + + det_table = QTable( + [ + Column(name="name", data=detlist), + Column( + name="telescope", + data=[chan_to_tel[odets[x]["channel"]] for x in detlist], + ), + Column(name="channel", data=[odets[x]["channel"] for x in detlist]), + Column(name="wafer", data=[odets[x]["wafer"] for x in detlist]), + Column(name="pixel", data=[odets[x]["pixel"] for x in detlist]), + Column(name="pixtype", data=[odets[x]["pixtype"] for x in detlist]), + Column(name="squid", data=[odets[x]["squid"] for x in detlist]), + Column(name="quat", data=[odets[x]["quat"] for x in detlist]), + Column(name="gamma", length=n_det, unit=u.rad), + Column(name="psi_pol", length=n_det, unit=u.rad), + Column(name="pol_leakage", data=np.zeros(n_det, dtype=np.float32)), + Column(name="fwhm", length=n_det, unit=u.arcmin), + Column( + name="ellipticity", data=[odets[x]["ellipticity"] for x in detlist] + ), + Column(name="bandcenter", length=n_det, unit=u.GHz), + Column(name="bandwidth", length=n_det, unit=u.GHz), + Column( + name="psd_net", length=n_det, unit=(u.K * np.sqrt(1.0 * u.second)) + ), + Column(name="psd_fknee", length=n_det, unit=u.Hz), + Column(name="psd_fmin", length=n_det, unit=u.Hz), + Column(name="psd_alpha", data=[odets[x]["alpha"] for x in detlist]), + Column(name="pol", data=[odets[x]["pol"] for x in detlist]), + Column(name="orient", data=[odets[x]["orient"] for x in detlist]), + Column(name="psd_dac", length=n_det, unit=u.K**2), + Column(name="pol_sensitivity", length=n_det, unit=u.K / u.arcmin), + ] + ) + for idet, det in enumerate(detlist): + det_table[idet]["gamma"] = 0.0 * u.rad + det_table[idet]["psi_pol"] = 0.0 * u.rad + det_table[idet]["fwhm"] = odets[det]["fwhm_arcmin"] * u.arcmin + det_table[idet]["bandcenter"] = odets[det]["bandcenter_ghz"] * u.GHz + det_table[idet]["bandwidth"] = odets[det]["bandwidth_ghz"] * u.GHz + det_table[idet]["psd_net"] = ( + odets[det]["net_ukrts"] * 1.0e-6 * (u.K * np.sqrt(1.0 * u.second)) + ) + det_table[idet]["psd_fknee"] = odets[det]["fknee_mhz"] * 1.0e-3 * u.Hz + det_table[idet]["psd_fmin"] = odets[det]["fmin_hz"] * u.Hz + det_table[idet]["psd_dac"] = ( + odets[det]["psd_dac_ukcmb^2"] * 1.0e-12 * (u.K**2) + ) + det_table[idet]["pol_sensitivity"] = ( + odets[det]["pol_sensitivity_ukarcmin"] * 1.0e-6 * (u.K / u.arcmin) + ) + + site = LitebirdSite() + focalplane = Focalplane( + detector_data=det_table, + sample_rate=rate, + ) + + tele = Telescope(tname, focalplane=focalplane, site=site) + tele.hwp_rpm = tel_data[tel]["hwp_rpm"] + tele.sampling_rate = u.Quantity(tel_data[tel]["sampling_rate_hz"], unit=u.Hz) + tele.spin_boresight_angle = u.Quantity( + tel_data[tel]["spin_boresight_angle_deg"], unit=u.degree + ) + tele.boresight_rotangle = u.Quantity( + tel_data[tel]["boresight_rotangle_deg"], unit=u.degree + ) + tele.spin_rotangle = u.Quantity( + tel_data[tel]["spin_rotangle_deg"], unit=u.degree + ) + obs_tel.append(tele) + return scan_data, obs_tel + + +class LitebirdSchedule(SatelliteSchedule): + def __init__( + self, + scan_props, + mission_start, + observation_time, + num_obs=None, + ): + log = Logger.get() + spin_rate_rpm = scan_props["spin_rate_rpm"] + spin_period = (1.0 / spin_rate_rpm) * u.minute + duty_cycle = scan_props["observation_duty_cycle"] + duration = scan_props["mission_duration_year"] * u.year + precession_period = scan_props["precession_period_min"] * u.minute + + obs_seconds = observation_time.to_value(u.second) + gap_seconds = (1.0 - duty_cycle) * obs_seconds / duty_cycle + total_seconds = obs_seconds + gap_seconds + + if num_obs is None: + # Simulating the full mission + num_obs = int(duration.to_value(u.second) / total_seconds) + else: + if num_obs * total_seconds > duration.to_value(u.second): + new_num_obs = int(duration.to_value(u.second) / total_seconds) + msg = f"Simulating {num_obs} observations of {total_seconds:0.2e}" + msg += f" seconds each exceeds mission duration. " + msg += f"Using {new_num_obs} instead" + num_obs = new_num_obs + log.warning(msg) + + if mission_start.tzinfo is None: + msg = f"Mission start time '{mission_start}' is not timezone-aware. Assuming UTC." + log.warning(msg) + mission_start = mission_start.replace(tzinfo=timezone.utc) + + obs = timedelta(seconds=obs_seconds) + gap = timedelta(seconds=gap_seconds) + epsilon = timedelta(seconds=0) + if gap_seconds == 0: + # If there is no gap, we add a tiny break (much less than one sample for any + # reasonable experiment) so that the start time of one observation is never + # identical to the stop time of the previous one. + epsilon = timedelta(microseconds=2) + + total = obs + gap + + scans = list() + for sc in range(num_obs): + start = sc * total + mission_start + stop = start + obs - epsilon + name = "{}{:06d}_{}".format("LB_", sc, start.isoformat(timespec="minutes")) + scans.append( + SatelliteScan( + name=name, + start=start, + stop=stop, + prec_period=precession_period, + spin_period=spin_period, + ) + ) + super().__init__( + scans=scans, + site_name="LiteBIRD", + telescope_name="LiteBIRD", + ) diff --git a/litebirdtask/ops/__init__.py b/litebirdtask/ops/__init__.py index 38aaaf0..15c166f 100644 --- a/litebirdtask/ops/__init__.py +++ b/litebirdtask/ops/__init__.py @@ -3,4 +3,4 @@ """LiteBIRD TOAST Operators. """ -from .sim_scan import SimScan +from .sim_observe import SimObserve diff --git a/litebirdtask/ops/sim_observe.py b/litebirdtask/ops/sim_observe.py new file mode 100644 index 0000000..07290c4 --- /dev/null +++ b/litebirdtask/ops/sim_observe.py @@ -0,0 +1,346 @@ +# Copyright (c) 2015-2023 by the parties listed in the AUTHORS file. +# All rights reserved. Use of this source code is governed by +# a BSD-style license that can be found in the LICENSE file. + +from datetime import datetime, timezone + +import traitlets +import numpy as np + +from astropy import units as u +from astropy.table import Column, QTable + +import toast.qarray as qa +from toast.traits import trait_docs, Int, Unicode, Float, Bool, Instance, Quantity, Unit +from toast.utils import Environment, Logger +from toast.dist import distribute_discrete +from toast.timing import function_timer, Timer +from toast import Telescope, SpaceSite +from toast.ops import Operator, SimSatellite +from toast.ops.sim_satellite import satellite_scanning +from toast.ops.sim_hwp import simulate_hwp_response +from toast.observation import Observation, Session +from toast.observation import default_values as defaults +from toast.schedule import SatelliteSchedule + +from ..instrument import load_imo, LitebirdSchedule + + +@trait_docs +class SimObserve(Operator): + """Simulate satellite scanning. + + This operator loads a set of detectors from the IMO and observes with the specified + schedule. + + """ + + # Class traits (we also inherit the traits of the toast.ops.SimSatellite class) + + imo_file = Unicode(None, allow_none=True, help="The path to an IMO file.") + + select_telescope = Unicode( + None, allow_none=True, help="Regular expression matching on telescope name" + ) + + select_channel = Unicode( + None, allow_none=True, help="Regular expression matching on channel name" + ) + + select_wafer = Unicode( + None, allow_none=True, help="Regular expression matching on wafer name" + ) + + select_pixel = Unicode( + None, allow_none=True, help="Regular expression matching on pixel name" + ) + + select_detector = Unicode( + None, allow_none=True, help="Regular expression matching on detector name" + ) + + mission_start = Unicode( + "2031-03-21T00:00:00+00:00", + help="The mission start time as an ISO 8601 format string", + ) + + observation_time = Quantity( + 60.0 * u.minute, + help="The time span of each science observation", + ) + + num_observation = Int(1, help="The number of observations") + + detset_key = Unicode( + None, + allow_none=True, + help="If specified, use this column of the focalplane detector_data to group detectors", + ) + + times = Unicode(defaults.times, help="Observation shared key for timestamps") + + shared_flags = Unicode( + defaults.shared_flags, + allow_none=True, + help="Observation shared key for common flags", + ) + + hwp_angle = Unicode( + defaults.hwp_angle, allow_none=True, help="Observation shared key for HWP angle" + ) + + boresight = Unicode( + defaults.boresight_radec, help="Observation shared key for boresight" + ) + + position = Unicode(defaults.position, help="Observation shared key for position") + + velocity = Unicode(defaults.velocity, help="Observation shared key for velocity") + + det_data = Unicode( + defaults.det_data, + allow_none=True, + help="Observation detdata key to initialize", + ) + + det_data_units = Unit( + defaults.det_data_units, help="Output units if creating detector data" + ) + + det_flags = Unicode( + defaults.det_flags, + allow_none=True, + help="Observation detdata key for flags to initialize", + ) + + wafer_obs = Bool( + False, help="If True, split detectors into observations by wafer, not channel" + ) + + distribute_time = Bool( + False, + help="Distribute observation data along the time axis rather than detector axis", + ) + + def __init__(self, **kwargs): + super().__init__(**kwargs) + + def _exec(self, data, detectors=None, **kwargs): + zaxis = np.array([0, 0, 1], dtype=np.float64) + + if detectors is not None: + msg = "Detectors should be selected through the IMO, " + msg += "not passed as a function argument." + raise RuntimeError(msg) + + # Load the IMO + obs_tel = None + scan_props = None + if data.comm.world_rank == 0: + scan_props, obs_tel = load_imo( + self.imo_file, + telescope=self.select_telescope, + channel=self.select_channel, + wafer=self.select_wafer, + pixel=self.select_pixel, + detector=self.select_detector, + wafer_obs=self.wafer_obs, + ) + if data.comm.comm_world is not None: + obs_tel = data.comm.comm_world.bcast(obs_tel, root=0) + scan_props = data.comm.comm_world.bcast(scan_props, root=0) + + # Data distribution in the detector direction + det_ranks = data.comm.group_size + if self.distribute_time: + det_ranks = 1 + + # Create the schedule + schedule = LitebirdSchedule( + scan_props, + datetime.fromisoformat(self.mission_start), + self.observation_time, + num_obs=self.num_observation, + ) + + # Distribute the schedule based on the time covered by each scan. + # The global start is the beginning of the first scan. + + if len(schedule.scans) == 0: + raise RuntimeError("Schedule has no scans!") + schedule_start = schedule.scans[0].start + + scan_seconds = list() + for scan in schedule.scans: + scan_seconds.append(int((scan.stop - scan.start).total_seconds())) + + # Distribute the observing sessions uniformly among groups. We take each scan and + # weight it by the duration. + + groupdist = distribute_discrete(scan_seconds, data.comm.ngroups) + group_firstobs = groupdist[data.comm.group][0] + group_numobs = groupdist[data.comm.group][1] + + for obindx in range(group_firstobs, group_firstobs + group_numobs): + scan = schedule.scans[obindx] + ses_start = scan.start.timestamp() + ses_stop = scan.stop.timestamp() + + session = Session( + f"{scan.name}_{int(ses_start):10d}", + start=scan.start.astimezone(timezone.utc), + end=scan.stop.astimezone(timezone.utc), + ) + + # For this observing session, loop over telescope objects and create + # observations. + + for tel in obs_tel: + focalplane = tel.focalplane + rate = focalplane.sample_rate.to_value(u.Hz) + incr = 1.0 / rate + + ffirst = rate * (scan.start - schedule_start).total_seconds() + first = int(ffirst) + if ffirst - first > 1.0e-3 * incr: + first += 1 + start = first * incr + schedule_start.timestamp() + scan_samples = 1 + int(rate * (scan.stop.timestamp() - start)) + stop = (scan_samples - 1) * incr + start + + # Get the detector sets + detsets = None + if self.detset_key is not None: + detsets = focalplane.detector_groups(self.detset_key) + + ob = Observation( + data.comm, + tel, + scan_samples, + name=f"{scan.name}_{int(ses_start)}_{tel.name}", + session=session, + detector_sets=detsets, + process_rows=det_ranks, + ) + + # Create shared objects for timestamps, common flags, position, + # and velocity. + ob.shared.create_column( + self.times, + shape=(ob.n_local_samples,), + dtype=np.float64, + ) + ob.shared.create_column( + self.shared_flags, + shape=(ob.n_local_samples,), + dtype=np.uint8, + ) + ob.shared.create_column( + self.position, + shape=(ob.n_local_samples, 3), + dtype=np.float64, + ) + ob.shared.create_column( + self.velocity, + shape=(ob.n_local_samples, 3), + dtype=np.float64, + ) + + # Rank zero of each grid column creates the data + + stamps = None + position = None + velocity = None + q_prec = None + + if ob.comm_col_rank == 0: + stamps = np.linspace( + start, + stop, + num=ob.n_local_samples, + endpoint=True, + dtype=np.float64, + ) + + # Get the motion of the site for these times. + position, velocity = tel.site.position_velocity(stamps) + + # Get the quaternions for the precession axis. For now, assume that + # it simply points away from the solar system barycenter + + pos_norm = np.sqrt((position * position).sum(axis=1)).reshape(-1, 1) + pos_norm = 1.0 / pos_norm + prec_axis = pos_norm * position + q_prec = qa.from_vectors( + np.tile(zaxis, ob.n_local_samples).reshape(-1, 3), prec_axis + ) + + ob.shared[self.times].set(stamps, offset=(0,), fromrank=0) + ob.shared[self.position].set(position, offset=(0, 0), fromrank=0) + ob.shared[self.velocity].set(velocity, offset=(0, 0), fromrank=0) + + # Create boresight pointing + + satellite_scanning( + ob, + self.boresight, + sample_offset=first, + q_prec=q_prec, + spin_period=scan.spin_period, + spin_angle=tel.spin_boresight_angle, + prec_period=scan.prec_period, + prec_angle=95 * u.degree - tel.spin_boresight_angle, + ) + + # Set HWP angle + + simulate_hwp_response( + ob, + ob_time_key=self.times, + ob_angle_key=self.hwp_angle, + ob_mueller_key=None, + hwp_start=start * u.second, + hwp_rpm=tel.hwp_rpm, + ) + + # Optionally initialize detector data + + dets = ob.select_local_detectors(detectors) + + if self.det_data is not None: + exists_data = ob.detdata.ensure( + self.det_data, + dtype=np.float64, + detectors=dets, + create_units=self.det_data_units, + ) + + if self.det_flags is not None: + exists_flags = ob.detdata.ensure( + self.det_flags, dtype=np.uint8, detectors=dets + ) + + data.obs.append(ob) + + def _finalize(self, data, **kwargs): + return + + def _requires(self): + return dict() + + def _provides(self): + prov = { + "shared": [ + self.times, + self.shared_flags, + self.boresight, + self.hwp_angle, + self.position, + self.velocity, + ] + } + if self.det_data is not None: + prov["detdata"].append(self.det_data) + if self.det_flags is not None: + prov["detdata"].append(self.det_flags) + return prov diff --git a/litebirdtask/scripts/hardware_info.py b/litebirdtask/scripts/hardware_info.py deleted file mode 100644 index 0145962..0000000 --- a/litebirdtask/scripts/hardware_info.py +++ /dev/null @@ -1,29 +0,0 @@ -# Copyright (c) 2015-2021 LiteBIRD Collaboration. -# Full license can be found in the top level "LICENSE" file. -"""Plot a hardware model. -""" - -import argparse - -from ..hardware import Hardware - -from ..vis import summary_text - - -def main(): - parser = argparse.ArgumentParser( - description="This program reads a hardware model and prints some\ - summary text to the terminal.", - usage="lbt_hardware_info [hardware file, [hardware_file]] ...", - ) - - parser.add_argument("hardware", type=str, nargs="+", help="Input hardware file") - - args = parser.parse_args() - - for file in args.hardware: - print("Loading hardware file {}...".format(file), flush=True) - hw = Hardware(file) - summary_text(hw) - - return diff --git a/litebirdtask/scripts/hardware_plot.py b/litebirdtask/scripts/hardware_plot.py deleted file mode 100644 index e7dd491..0000000 --- a/litebirdtask/scripts/hardware_plot.py +++ /dev/null @@ -1,70 +0,0 @@ -# Copyright (c) 2015-2021 LiteBIRD Collaboration. -# Full license can be found in the top level "LICENSE" file. -"""Plot a hardware model. -""" - -import argparse - -from ..hardware import Hardware - -from ..vis import plot_detectors - - -def main(): - parser = argparse.ArgumentParser( - description="This program reads a hardware model and plots the\ - detectors. Note that you should pre-select detectors before\ - passing a hardware model to this function. See lb_hardware_trim.", - usage="lbt_hardware_plot [options] (use --help for details)", - ) - - parser.add_argument( - "--hardware", required=True, default=None, help="Input hardware file" - ) - - parser.add_argument( - "--out", required=False, default=None, help="Name of the output PDF file." - ) - - parser.add_argument( - "--width", - required=False, - default=None, - help="The width of the plot in degrees.", - ) - - parser.add_argument( - "--height", - required=False, - default=None, - help="The height of the plot in degrees.", - ) - - parser.add_argument( - "--labels", - required=False, - default=False, - action="store_true", - help="Add pixel and polarization labels to the plot.", - ) - - args = parser.parse_args() - - outfile = args.out - if outfile is None: - fields = args.hardware.split(".") - outfile = fields[0] - - print("Loading hardware file {}...".format(args.hardware), flush=True) - hw = Hardware(args.hardware) - - print("Generating detector plot...", flush=True) - plot_detectors( - hw.data["detectors"], - outfile, - width=args.width, - height=args.height, - labels=args.labels, - ) - - return diff --git a/litebirdtask/scripts/imo_info.py b/litebirdtask/scripts/imo_info.py new file mode 100644 index 0000000..adcf8f9 --- /dev/null +++ b/litebirdtask/scripts/imo_info.py @@ -0,0 +1,70 @@ +# Copyright (c) 2015-2023 by enities listed in the top-level AUTHORS file. +# Full license can be found in the top level LICENSE file. +"""Print information about an instrument model. +""" + +import argparse + +from ..instrument import load_imo + +from ..vis import summary_text + + +def main(): + parser = argparse.ArgumentParser( + description="This program reads an IMO and prints some\ + summary text to the terminal.", + usage="lbt_imo_info [options] ", + ) + + parser.add_argument("imo", type=str, help="IMO file") + + parser.add_argument( + "--telescope", + type=str, + default=None, + help="Telescope selection as a regular expression" + ) + + parser.add_argument( + "--channel", + type=str, + default=None, + help="Channel selection as a regular expression" + ) + + parser.add_argument( + "--wafer", + type=str, + default=None, + help="Wafer selection as a regular expression" + ) + + parser.add_argument( + "--detector", + type=str, + default=None, + help="detector selection as a regular expression" + ) + + args = parser.parse_args() + + scan_props, tele_list = load_imo( + args.imo, + telescope=args.telescope, + channel=args.channel, + wafer=args.wafer, + pixel=None, + detector=args.detector, + ) + + summary_text(scan_props, tele_list) + + if len(tele_list) == 1: + fp = tele_list[0].focalplane + det_props = fp.detector_data + if len(det_props) == 1: + for col in det_props.colnames: + print(f" {col} = {det_props[col][0]}") + + return diff --git a/litebirdtask/scripts/imo_plot.py b/litebirdtask/scripts/imo_plot.py new file mode 100644 index 0000000..ba23370 --- /dev/null +++ b/litebirdtask/scripts/imo_plot.py @@ -0,0 +1,68 @@ +# Copyright (c) 2015-2023 by enities listed in the top-level AUTHORS file. +# Full license can be found in the top level LICENSE file. +"""Plot an instrument model. +""" + +import argparse + +from ..instrument import load_imo + +from ..vis import plot_detectors + + +def main(): + parser = argparse.ArgumentParser( + description="This program reads an IMO and plots the detectors", + usage="lbt_imo_plot [options] (use --help for details)", + ) + + # parser.add_argument( + # "--hardware", required=True, default=None, help="Input hardware file" + # ) + + # parser.add_argument( + # "--out", required=False, default=None, help="Name of the output PDF file." + # ) + + # parser.add_argument( + # "--width", + # required=False, + # default=None, + # help="The width of the plot in degrees.", + # ) + + # parser.add_argument( + # "--height", + # required=False, + # default=None, + # help="The height of the plot in degrees.", + # ) + + # parser.add_argument( + # "--labels", + # required=False, + # default=False, + # action="store_true", + # help="Add pixel and polarization labels to the plot.", + # ) + + # args = parser.parse_args() + + # outfile = args.out + # if outfile is None: + # fields = args.hardware.split(".") + # outfile = fields[0] + + # print("Loading hardware file {}...".format(args.hardware), flush=True) + # hw = Hardware(args.hardware) + + # print("Generating detector plot...", flush=True) + # plot_detectors( + # hw.data["detectors"], + # outfile, + # width=args.width, + # height=args.height, + # labels=args.labels, + # ) + + return diff --git a/litebirdtask/tests/__init__.py b/litebirdtask/tests/__init__.py new file mode 100644 index 0000000..e1765db --- /dev/null +++ b/litebirdtask/tests/__init__.py @@ -0,0 +1,7 @@ +# Copyright (c) 2015-2023 by the parties listed in the AUTHORS file. +# All rights reserved. Use of this source code is governed by +# a BSD-style license that can be found in the LICENSE file. +"""Unit tests for the litebirdtask package. +""" + +from .runner import test as run diff --git a/litebirdtask/tests/_helpers.py b/litebirdtask/tests/_helpers.py new file mode 100644 index 0000000..2c03eb1 --- /dev/null +++ b/litebirdtask/tests/_helpers.py @@ -0,0 +1,81 @@ +# Copyright (c) 2015-2023 by the parties listed in the AUTHORS file. +# All rights reserved. Use of this source code is governed by +# a BSD-style license that can be found in the LICENSE file. + +import os +from datetime import datetime + +from astropy import units as u + +import toast +from toast.schedule_sim_satellite import create_satellite_schedule +from toast.tests._helpers import create_comm + +from .. import ops + + +def create_outdir(mpicomm, subdir=None): + """Create the top level output directory and per-test subdir. + + Args: + mpicomm (MPI.Comm): the MPI communicator (or None). + subdir (str): the sub directory for this test. + + Returns: + str: full path to the test subdir if specified, else the top dir. + + """ + pwd = os.path.abspath(".") + testdir = os.path.join(pwd, "litebirdtask_test_output") + retdir = testdir + if subdir is not None: + retdir = os.path.join(testdir, subdir) + if (mpicomm is None) or (mpicomm.rank == 0): + if not os.path.isdir(testdir): + os.mkdir(testdir) + if not os.path.isdir(retdir): + os.mkdir(retdir) + if mpicomm is not None: + mpicomm.barrier() + return retdir + + +def create_scanning( + mpicomm, + imo_path, + tel="LFT", + channel="L1-040", + wafer="L00", + session_per_group=1, + session_time=10.0 * u.minute, +): + """Create a data object with a simulated scanning schedule. + + Use the specified MPI communicator to attempt to create 2 process groups. + + Args: + mpicomm (MPI.Comm): the MPI communicator (or None). + obs_per_group (int): the number of observations assigned to each group. + obs_time (Quantity): the time length of one observation. + + Returns: + toast.Data: the distributed data with named observations. + + """ + toastcomm = create_comm(mpicomm) + data = toast.Data(toastcomm) + + # Create the scanning data + + sim_obs = ops.SimObserve( + imo_file=imo_path, + select_telescope=tel, + select_channel=channel, + select_wafer=wafer, + observation_time=session_time, + num_observation=(toastcomm.ngroups * session_per_group), + detset_key="pixel", + ) + sim_obs.apply(data) + + return data \ No newline at end of file diff --git a/litebirdtask/tests/ops_sim_observe.py b/litebirdtask/tests/ops_sim_observe.py new file mode 100644 index 0000000..35f707b --- /dev/null +++ b/litebirdtask/tests/ops_sim_observe.py @@ -0,0 +1,149 @@ +# Copyright (c) 2015-2023 by the parties listed in the AUTHORS file. +# All rights reserved. Use of this source code is governed by +# a BSD-style license that can be found in the LICENSE file. + +import os +from datetime import datetime + +from astropy import units as u +import numpy as np +import healpy as hp + +import toast.ops +from toast.schedule_sim_satellite import create_satellite_schedule +from toast.instrument_sim import plot_focalplane +from toast.tests.mpi import MPITestCase +from toast.tests._helpers import create_comm, close_data, plot_projected_quats +from toast.observation import default_values as defaults +from toast.pixels_io_healpix import write_healpix_fits +from toast.vis import set_matplotlib_backend + +from .. import ops +from ..instrument import load_imo +from ._helpers import create_outdir, create_scanning + + +class SimObserveTest(MPITestCase): + def setUp(self): + fixture_name = os.path.splitext(os.path.basename(__file__))[0] + self.outdir = create_outdir(self.comm, fixture_name) + self.toastcomm = create_comm(self.comm) + self.imo_path = None + if "LB_IMO_FILE" in os.environ: + self.imo_path = os.environ["LB_IMO_FILE"] + + def test_imo(self): + if self.imo_path is None: + print("'LB_IMO_FILE' not in environment, skipping tests") + return + + scan_props, imo = load_imo( + self.imo_path, + telescope="MFT", + channel="M2-119", + ) + + first_fp = imo[0].focalplane + + default_pixel_colors = { + "LP1": (1.0, 0.0, 0.0, 0.2), + "LP2": (0.4, 0.4, 1.0, 0.2), + "LP3": (0.4, 0.4, 1.0, 0.2), + "LP4": (0.4, 0.4, 1.0, 0.2), + "MP1": (0.4, 1.0, 0.4, 0.2), + "MP2": (0.4, 1.0, 0.4, 0.2), + "HP1": (1.0, 0.4, 0.4, 0.2), + "HP2": (1.0, 0.4, 0.4, 0.2), + "HP3": (1.0, 0.4, 0.4, 0.2), + } + + face_color = dict() + pol_color = dict() + for d in first_fp.detectors: + detcolor = "black" + if first_fp[d]["pol"] == "T": + detcolor = (1.0, 0.0, 0.0, 1.0) + if first_fp[d]["pol"] == "B": + detcolor = (0.0, 0.0, 1.0, 1.0) + pol_color[d] = detcolor + face_color[d] = default_pixel_colors[first_fp[d]["pixtype"]] + + plot_focalplane( + focalplane=imo[0].focalplane, + width=25.0 * u.degree, + height=25.0 * u.degree, + face_color=face_color, + pol_color=pol_color, + show_labels=True, + xieta=False, + outfile=os.path.join(self.outdir, "imo_test.pdf") + ) + + def test_exec(self): + if self.imo_path is None: + print("'LB_IMO_FILE' not in environment, skipping tests") + return + + data = create_scanning( + self.comm, + self.imo_path, + # tel="MFT", + # channel="M2-119", + tel="LFT", + channel="L1-040", + wafer=None, + session_per_group=10, + session_time=60.0 * u.minute, + ) + + # Plot some pointing + plotdetpointing = toast.ops.PointingDetectorSimple( + boresight=defaults.boresight_radec, + quats="pquats", + ) + plotdetpointing.apply(data) + if data.comm.world_rank == 0: + n_debug = 1000 + bquat = np.array(data.obs[0].shared[defaults.boresight_radec][0:n_debug, :]) + dquat = data.obs[0].detdata["pquats"][:, 0:n_debug, :] + invalid = np.array(data.obs[0].shared[defaults.shared_flags][0:n_debug]) + invalid &= defaults.shared_mask_invalid + valid = np.logical_not(invalid) + outfile = os.path.join(self.outdir, "pointing.pdf") + plot_slc = slice(0, n_debug, 100) + plot_projected_quats( + outfile, qbore=bquat, qdet=dquat, valid=plot_slc, scale=1.0 + ) + + # Expand pointing and make a hit map. + detpointing = toast.ops.PointingDetectorSimple() + pixels = toast.ops.PixelsHealpix( + nest=True, + create_dist="pixel_dist", + detector_pointing=detpointing, + ) + pixels.nside_submap = 2 + pixels.nside = 64 + pixels.apply(data) + + build_hits = toast.ops.BuildHitMap(pixel_dist="pixel_dist", pixels=pixels.pixels) + build_hits.apply(data) + + # Plot the hits + + hit_path = os.path.join(self.outdir, "hits.fits") + write_healpix_fits(data[build_hits.hits], hit_path, nest=pixels.nest) + + if data.comm.world_rank == 0: + set_matplotlib_backend() + import matplotlib.pyplot as plt + + hits = hp.read_map(hit_path, field=None, nest=pixels.nest) + outfile = os.path.join(self.outdir, "hits.png") + hp.mollview(hits, xsize=1600, nest=True) + plt.savefig(outfile) + plt.close() + + close_data(data) + + diff --git a/litebirdtask/tests/runner.py b/litebirdtask/tests/runner.py new file mode 100644 index 0000000..0804389 --- /dev/null +++ b/litebirdtask/tests/runner.py @@ -0,0 +1,66 @@ +# Copyright (c) 2015-2023 by the parties listed in the AUTHORS file. +# All rights reserved. Use of this source code is governed by +# a BSD-style license that can be found in the LICENSE file. + +import os +import shutil +import sys +import unittest + +from toast.mpi import MPI, use_mpi +from toast.tests.mpi import MPITestRunner + +from . import ops_sim_observe as test_ops_sim_observe + + +def test(name=None, verbosity=2): + # We run tests with COMM_WORLD if available + comm = None + rank = 0 + if use_mpi: + comm = MPI.COMM_WORLD + rank = comm.rank + + outdir = "litebirdtask_test_output" + + if rank == 0: + outdir = os.path.abspath(outdir) + if os.path.isdir(outdir): + shutil.rmtree(outdir) + os.makedirs(outdir) + + if comm is not None: + outdir = comm.bcast(outdir, root=0) + + # Run python tests. + + loader = unittest.TestLoader() + mpirunner = MPITestRunner(verbosity=verbosity, warnings="ignore") + suite = unittest.TestSuite() + + if name is None: + suite.addTest(loader.loadTestsFromModule(test_ops_sim_observe)) + else: + modname = "litebirdtask.tests.{}".format(name) + if modname not in sys.modules: + result = f"'{name}' is not a valid test. Try" + for name in sys.modules: + if name.startswith("litebirdtask.tests."): + result += '\n - "{}"'.format(name.replace("litebirdtask.tests.", "")) + result += "\n" + raise RuntimeError(result) + suite.addTest(loader.loadTestsFromModule(sys.modules[modname])) + + ret = 0 + _ret = mpirunner.run(suite) + if not _ret.wasSuccessful(): + ret += 1 + + if comm is not None: + ret = comm.allreduce(ret, op=MPI.SUM) + + if ret > 0: + print(f"{ret} Processes had failures") + sys.exit(6) + + return ret diff --git a/litebirdtask/vis.py b/litebirdtask/vis.py index ff492a3..622644a 100644 --- a/litebirdtask/vis.py +++ b/litebirdtask/vis.py @@ -222,34 +222,57 @@ def disable(self): self.ENDC = "" -def summary_text(hw): - """Print a textual summary of a hardware configuration. +def summary_text(scan_props, obs_tele): + """Print a textual summary of the detectors included in a job. Args: - hw (Hardware): A hardware dictionary. + scan_props (dict): The scan properties returned by load_imo() + obs_tele (list): A list of per-observation Telescope instances. Returns: None """ - for obj, props in hw.data.items(): - nsub = len(props) + tele_list = set() + channel_list = set() + wafer_list = set() + det_list = set() + for tobs in obs_tele: + fp = tobs.focalplane + detinfo = fp.detector_data + tele_list.update(detinfo["telescope"][:]) + wafer_list.update(detinfo["wafer"][:]) + channel_list.update(detinfo["channel"][:]) + det_list.update(detinfo["name"][:]) + tele_list = list(sorted(tele_list)) + channel_list = list(sorted(channel_list)) + wafer_list = list(sorted(wafer_list)) + det_list = list(sorted(det_list)) + + def _display(objname, listing): + nobj = len(listing) print( - "{}{:<12}: {}{:5d} objects{}".format( - clr.WHITE, obj, clr.RED, nsub, clr.ENDC - ) + f"{clr.GREEN}{objname:<12}: {clr.RED}{nobj:5d} objects{clr.ENDC}" ) - if nsub <= 2000: + if nobj <= 2000: line = "" - for k in list(props.keys()): - if (len(line) + len(k)) > 72: - print(" {}{}{}".format(clr.BLUE, line, clr.ENDC)) + for obj in listing: + if (len(line) + len(obj)) > 72: + print(f" {clr.BLUE}{line}{clr.ENDC}") line = "" - line = "{}{}, ".format(line, k) + line = f"{line}{obj}, " if len(line) > 0: - print(" {}{}{}".format(clr.BLUE, line.rstrip(", "), clr.ENDC)) + print(f" {clr.BLUE}{line.rstrip(', ')}{clr.ENDC}") else: - # Too many to print! - print(" {}(Too many to print){}".format(clr.BLUE, clr.ENDC)) - - return + print(f" {clr.BLUE}(Too many to print){clr.ENDC}") + + print( + f"{clr.GREEN}Scanning Properties:{clr.ENDC}" + ) + for k, v in scan_props.items(): + print(f" {clr.BLUE}{k} = {v}{clr.ENDC}") + + _display("Telescopes", tele_list) + _display("Channels", channel_list) + _display("Wafers", wafer_list) + _display("Detectors", det_list) diff --git a/litebirdtask/workflow/__init__.py b/litebirdtask/workflow/__init__.py new file mode 100644 index 0000000..6940325 --- /dev/null +++ b/litebirdtask/workflow/__init__.py @@ -0,0 +1,18 @@ +# Copyright (c) 2023-2023 by enities listed in the top-level AUTHORS file. +# Full license can be found in the top level LICENSE file. +"""High-level workflow helper functions. +""" + +# Namespace imports + +from .pointing import add_pointing_operators, select_pointing +from .sim import add_sim_observe_operators, add_sim_operators, sim_observe, sim_data +from .data import add_data_args, load_data +from .processing import ( + add_simple_noise_operators, + add_noise_operators, + add_mapmaking_operators, + run_simple_models, + run_noise_estimation, + run_mapmaking, +) diff --git a/litebirdtask/workflow/data.py b/litebirdtask/workflow/data.py new file mode 100644 index 0000000..32ae7dc --- /dev/null +++ b/litebirdtask/workflow/data.py @@ -0,0 +1,67 @@ +# Copyright (c) 2023-2023 by enities listed in the top-level AUTHORS file. +# Full license can be found in the top level LICENSE file. +"""High-level workflow data I/O. +""" + +import os +from ast import literal_eval as make_tuple + +import numpy as np +from astropy import units as u + +import toast +from toast.observation import default_values as defaults +from toast.utils import Logger + + +def add_data_args(parser): + """Add commandline args for data loading. + + Since there is no real data yet, this currently just supports loading + toast Observation dumps. + + """ + parser.add_argument( + "--obs_hdf5", + required=False, + action="extend", + nargs="*", + help="Path to a TOAST hdf5 observation dump (can use multiple times)", + ) + + +def load_data(job, args, mpi_comm): + """Load one or more observations from disk. + """ + log = Logger.get() + + # Configured operators for this job + job_ops = job.operators + + # Create the toast communicator. We will use one group + # containing all processes. + gsize = 1 + if mpi_comm is not None: + gsize = mpi_comm.size + toast_comm = toast.Comm(world=mpi_comm, groupsize=gsize) + + # The data container + data = toast.Data(comm=toast_comm) + + for hobs in list(args.obs_hdf5): + log.info_rank(f"Starting load of HDF5 data {hobs}", comm=data.comm.comm_group) + ob = toast.io.load_hdf5( + hobs, + toast_comm, + process_rows=toast_comm.group_size, + meta=None, + detdata=None, + shared=None, + intervals=None, + force_serial=True, + ) + data.obs.append(ob) + + return data + + \ No newline at end of file diff --git a/litebirdtask/workflow/pointing.py b/litebirdtask/workflow/pointing.py new file mode 100644 index 0000000..e00bad0 --- /dev/null +++ b/litebirdtask/workflow/pointing.py @@ -0,0 +1,82 @@ +# Copyright (c) 2021-2023 by enities listed in the top-level AUTHORS file. +# Full license can be found in the top level LICENSE file. +"""High-level workflow pointing operations. +""" + +from astropy import units as u + +import toast +from toast.observation import default_values as defaults + + +def add_pointing_operators(operators): + operators.append( + toast.ops.PointingDetectorSimple( + name="det_pointing_radec", quats=defaults.quats + ) + ) + operators.append( + toast.ops.PixelsHealpix( + name="pixels", + nest=True, + nside=1024, + nside_submap=16, + ) + ) + operators.append( + toast.ops.PixelsHealpix( + name="pixels_final", + nest=True, + nside=1024, + nside_submap=16, + enabled=False, + ) + ) + operators.append( + toast.ops.StokesWeights( + name="weights_radec", weights="weights_radec", mode="IQU" + ) + ) + + +def select_pointing(job, args, data): + """Select the pixelization scheme for both the solver and final binning.""" + log = toast.utils.Logger.get() + + job_ops = job.operators + + job_ops.det_pointing_radec.boresight = defaults.boresight_radec + + job_ops.pixels.detector_pointing = job_ops.det_pointing_radec + + job_ops.weights_radec.detector_pointing = job_ops.det_pointing_radec + job_ops.weights_radec.hwp_angle = defaults.hwp_angle + + # Select Pixelization and weights for solve and final binning + + job.pixels_solve = job_ops.pixels + job.weights_solve = job_ops.weights_radec + + if job_ops.pixels_final.enabled: + # The user enabled a different pixelization for the final map + job.pixels_final = job_ops.pixels_final + else: + job.pixels_final = job.pixels_solve + job.weights_final = job.weights_solve + + log.info_rank( + f"Template solve using pixelization: {job.pixels_solve.name}", + comm=data.comm.comm_world, + ) + log.info_rank( + f"Template solve using weights: {job.weights_solve.name}", + comm=data.comm.comm_world, + ) + log.info_rank( + f"Final binning using pixelization: {job.pixels_final.name}", + comm=data.comm.comm_world, + ) + log.info_rank( + f"Final binning using weights: {job.weights_final.name}", + comm=data.comm.comm_world, + ) diff --git a/litebirdtask/workflow/processing.py b/litebirdtask/workflow/processing.py new file mode 100644 index 0000000..38b9cd6 --- /dev/null +++ b/litebirdtask/workflow/processing.py @@ -0,0 +1,193 @@ +# Copyright (c) 2023-2023 by enities listed in the top-level AUTHORS file. +# Full license can be found in the top level LICENSE file. +"""High-level workflow data processing. +""" + +import os + +import numpy as np +from astropy import units as u + +import toast +from toast.observation import default_values as defaults +import toast.ops + + +def add_simple_noise_operators(operators): + """Add basic nominal noise models""" + operators.append(toast.ops.DefaultNoiseModel(name="default_model")) + + +def add_noise_operators(operators): + operators.append( + toast.ops.NoiseEstim( + name="noise_estim", + out_model="noise_est", + lagmax=1024, + nbin_psd=128, + nsum=1, + naverage=64, + ) + ) + operators.append( + toast.ops.FitNoiseModel( + name="fit_estim", + out_model="fit_noise", + ) + ) + operators.append( + toast.ops.FlagNoiseFit( + name="flag_fit", + noise_model="fit_noise", + ) + ) + + +def add_mapmaking_operators(operators, templates): + templates.append( + toast.templates.Offset( + name="baselines", + use_noise_prior=False, + step_time=2.0 * u.second, + ) + ) + operators.append(toast.ops.BinMap(name="binner")) + operators.append( + toast.ops.MapMaker( + name="litebird", + solve_rcond_threshold=1e-3, + map_rcond_threshold=1e-3, + iter_min=30, + iter_max=200, + write_hits=True, + write_map=True, + write_binmap=True, + write_cov=True, + ) + ) + + +def run_simple_models(job, args, data): + log = toast.utils.Logger.get() + world_comm = data.comm.comm_world + + # Configured operators for this job + job_ops = job.operators + + # Timer for reporting the progress + timer = toast.timing.Timer() + timer.start() + + # Simple noise models + job_ops.default_model.apply(data) + + # Set the default noise model to the nominal one. + job.map_noise_model = job_ops.default_model.noise_model + + timer.stop() + + +def run_noise_estimation(job, args, data): + log = toast.utils.Logger.get() + world_comm = data.comm.comm_world + + # Configured operators for this job + job_ops = job.operators + + # Timer for reporting the progress + timer = toast.timing.Timer() + timer.start() + + # Estimate noise. If the noise estimation is disabled at runtime, use the + # default noise model. + + if job_ops.noise_estim.enabled: + job_ops.noise_estim.det_data = defaults.det_data + job_ops.noise_estim.apply(data) + log.info_rank("Estimated noise in", comm=world_comm, timer=timer) + + # Create a fit to this noise model + if job_ops.fit_estim.enabled: + job_ops.fit_estim.noise_model = job_ops.noise_estim.out_model + job_ops.fit_estim.apply(data) + log.info_rank("Fit 1/f noise model in", comm=world_comm, timer=timer) + job.map_noise_model = job_ops.fit_estim.out_model + # Flag detector outliers + job_ops.flag_fit.apply(data) + log.info_rank("Flag noise model outliers in", comm=world_comm, timer=timer) + else: + job.map_noise_model = job_ops.noise_estim.out_model + + if args.debug: + from toast.vis import plot_noise_estim + + # Plot the noise estimate fits + nse_dir = os.path.join(args.out_dir, "noise_estim") + if data.comm.world_rank == 0: + os.makedirs(nse_dir) + if data.comm.comm_world is not None: + data.comm.comm_world.barrier() + for ob in data.obs: + est_model = ob[job_ops.noise_estim.out_model] + if job_ops.fit_estim.enabled: + fit_model = ob[job_ops.fit_estim.out_model] + for det in ob.local_detectors: + fname = os.path.join(nse_dir, f"{ob.name}_{det}.pdf") + plot_noise_estim( + fname, + est_model.freq(det), + est_model.psd(det), + fit_freq=fit_model.freq(det), + fit_psd=fit_model.psd(det), + semilog=True, + ) + else: + for det in ob.local_detectors: + fname = os.path.join(nse_dir, f"{ob.name}_{det}.pdf") + plot_noise_estim( + fname, + est_model.freq(det), + est_model.psd(det), + semilog=True, + ) + timer.stop() + + +def run_mapmaking(job, args, data): + log = toast.utils.Logger.get() + world_comm = data.comm.comm_world + + # Configured operators for this job + job_ops = job.operators + + # Configured templates + job_tmpls = job.templates + + # Timer for reporting the progress + timer = toast.timing.Timer() + timer.start() + + # Set up the binning operator + + job_ops.binner.pixel_dist = "pixel_dist" + job_ops.binner.pixel_pointing = job.pixels_solve + job_ops.binner.stokes_weights = job.weights_solve + job_ops.binner.noise_model = job.map_noise_model + + # Set up the template matrix + + job_tmpls.baselines.noise_model = job.map_noise_model + tmatrix = toast.ops.TemplateMatrix( + templates=[job_tmpls.baselines], + ) + + # Set up the mapmaker + + if args.debug: + job_ops.litebird.keep_solver_products = True + job_ops.litebird.binning = job_ops.binner + job_ops.litebird.template_matrix = tmatrix + job_ops.litebird.det_data = defaults.det_data + job_ops.litebird.output_dir = args.out_dir + job_ops.litebird.apply(data) + log.info_rank("Finished map-making in", comm=world_comm, timer=timer) diff --git a/litebirdtask/workflow/sim.py b/litebirdtask/workflow/sim.py new file mode 100644 index 0000000..4efe9f7 --- /dev/null +++ b/litebirdtask/workflow/sim.py @@ -0,0 +1,102 @@ +# Copyright (c) 2021-2023 by enities listed in the top-level AUTHORS file. +# Full license can be found in the top level LICENSE file. +"""High-level workflow simulation functions. +""" + +import os +import numpy as np + +import toast +import toast.ops +from toast.observation import default_values as defaults + +from .. import ops as lbtops + + +def add_sim_observe_operators(operators): + """Add the litebird operator for simulated observing. + """ + operators.append( + lbtops.SimObserve( + name="sim_observe", + detset_key="pixel", + ) + ) + + +def add_sim_operators(operators): + """Our standard set of simulation operators to configure from a job. + """ + operators.extend( + [ + toast.ops.SimDipole( + name="sim_dipole", + mode="total", + ), + toast.ops.ScanHealpixMap(name="scan_map"), + toast.ops.SimNoise(name="sim_noise"), + toast.ops.SaveHDF5(name="save_hdf5"), + ] + ) + + +def sim_observe(job, args, jobargs, comm): + """Run simulated observing. + """ + ops = job.operators + if ops.sim_observe.imo_file is None: + msg = f"You must set the {ops.sim_observe.name}.imo_file trait before running" + raise RuntimeError(msg) + group_size = jobargs.group_size + if group_size is None: + group_size = 1 + if comm is not None: + group_size = comm.size + + toast_comm = toast.mpi.Comm(world=comm, groupsize=group_size) + data = toast.Data(comm=toast_comm) + ops.sim_observe.apply(data) + return data + + +def sim_data(job, args, data): + """Perform nominal data simulation with configured operators.""" + log = toast.utils.Logger.get() + ops = job.operators + world_comm = data.comm.comm_world + + # Timer for reporting the progress + timer = toast.timing.Timer() + timer.start() + + # Set the detector data to zero if it is not already + toast.ops.Reset(detdata=[defaults.det_data]).apply(data) + + # Load simulated sky signal + if ops.scan_map.enabled and ops.scan_map.file is not None: + log.info_rank("Begin simulated sky signal", comm=world_comm) + ops.scan_map.apply(data) + log.info_rank("Finished simulated sky signal in", comm=world_comm, timer=timer) + + # Simulated Dipole + if ops.sim_dipole.enabled: + log.info_rank("Begin dipole simulation", comm=world_comm) + ops.sim_dipole.det_data = defaults.det_data + ops.sim_dipole.apply(data) + log.info_rank("Finished dipole sim in", comm=world_comm, timer=timer) + + # Accumulate instrumental noise + if ops.sim_noise.enabled: + log.info_rank("Begin instrument noise simulation", comm=world_comm) + ops.sim_noise.noise_model = ops.default_model.noise_model + ops.sim_noise.det_data = defaults.det_data + ops.sim_noise.apply(data) + log.info_rank("Finished instrument noise sim in", comm=world_comm, timer=timer) + + # Optionally write out the data + if ops.save_hdf5.enabled: + log.info_rank("Begin save HDF5 data", comm=world_comm) + if ops.save_hdf5.volume is None: + ops.save_hdf5.volume = os.path.join(args.out_dir, "data") + ops.save_hdf5.apply(data) + log.info_rank("Finished save HDF5 data in", comm=world_comm, timer=timer) diff --git a/setup.py b/setup.py index f99ad9e..efd8947 100644 --- a/setup.py +++ b/setup.py @@ -24,17 +24,18 @@ def readme(): packages=find_packages(where="."), entry_points={ "console_scripts": [ - "lbt_hardware_plot = litebirdtask.scripts.hardware_plot:main", - "lbt_hardware_trim = litebirdtask.scripts.hardware_trim:main", - "lbt_hardware_info = litebirdtask.scripts.hardware_info:main", - "lbt_export_focalplane = litebirdtask.scripts.export_focalplane:main", - "lbt_hardware_from_imo =litebirdtask.scripts.hardware_from_imo:main" + "lbt_imo_plot = litebirdtask.scripts.imo_plot:main", + "lbt_imo_info = litebirdtask.scripts.imo_info:main", ] }, + scripts=[ + "workflows/lbt_sim.py", + "workflows/lbt_map.py", + ], license="BSD", - python_requires=">=3.7.0", + python_requires=">=3.8.0", setup_requires=["wheel"], - install_requires=["toml",], + install_requires=["toast>=3.0.0a16",], cmdclass=versioneer.get_cmdclass(), classifiers=[ "Development Status :: 4 - Beta", @@ -42,9 +43,10 @@ def readme(): "Intended Audience :: Science/Research", "License :: OSI Approved :: BSD License", "Operating System :: POSIX", - "Programming Language :: Python :: 3.7", "Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", "Topic :: Scientific/Engineering :: Astronomy", ], ) diff --git a/workflows/lbt_map.py b/workflows/lbt_map.py new file mode 100755 index 0000000..fc1358a --- /dev/null +++ b/workflows/lbt_map.py @@ -0,0 +1,127 @@ +#!/usr/bin/env python3 +# Copyright (c) 2023-2023 by enities listed in the top-level AUTHORS file. +# Full license can be found in the top level LICENSE file. + +""" +This script loads LiteBIRD TOAST data and makes a map. +""" + +import argparse +import os + +from litebirdtask import workflow + +import toast + + +def parse_config(operators, templates, comm): + """Parse command line arguments and load any config files. + + Return the final config, remaining args, and job size args. + + """ + # Argument parsing + parser = argparse.ArgumentParser(description="LiteBIRD Mapmaking") + + # Arguments for this workflow + parser.add_argument( + "--out_dir", + required=False, + type=str, + default=".", + help="Output directory.", + ) + + parser.add_argument( + "--debug", + required=False, + default=False, + action="store_true", + help="Make additional plots / checks for debugging", + ) + + workflow.add_data_args(parser) + + # Build a config dictionary starting from the operator defaults, overriding with any + # config files specified with the '--config' commandline option, followed by any + # individually specified parameter overrides. + + config, args, jobargs = toast.parse_config( + parser, + operators=operators, + templates=templates, + ) + + # Create our output directory + if comm is None or comm.rank == 0: + if not os.path.isdir(args.out_dir): + os.makedirs(args.out_dir) + + # Log the config that was actually used at runtime. + outlog = os.path.join(args.out_dir, "config_log.toml") + toast.config.dump_toml(outlog, config, comm=comm) + + return config, args, jobargs + + +@toast.timing.function_timer +def main(): + env = toast.utils.Environment.get() + log = toast.utils.Logger.get() + gt = toast.timing.GlobalTimers.get() + gt.start("lbt_sim (total)") + + # Get optional MPI parameters + comm, procs, rank = toast.get_world() + + # The operators we want to configure from the command line or a parameter file. + # We will use other operators, but these are the ones that the user can configure. + # The "name" of each operator instance controls what the commandline and config + # file options will be called. + # + # We can also set some default values here for the traits, including whether an + # operator is disabled by default. + + operators = list() + templates = list() + + # Default noise model + workflow.add_simple_noise_operators(operators) + + # Pointing model + workflow.add_pointing_operators(operators) + + # Noise model + workflow.add_noise_operators(operators) + + # Mapmaking + workflow.add_mapmaking_operators(operators, templates) + + # Parse options + config, args, jobargs = parse_config(operators, templates, comm) + + # Instantiate our operators / templates that were configured from the + # command line / files + job = toast.create_from_config(config) + + # Load the data + data = workflow.load_data(job, args, comm) + + # Processing + + workflow.run_simple_models(job, args, data) + workflow.select_pointing(job, args, data) + workflow.run_noise_estimation(job, args, data) + workflow.run_mapmaking(job, args, data) + + # Collect optional timing information + alltimers = toast.timing.gather_timers(comm=data.comm.comm_world) + if data.comm.world_rank == 0: + out = os.path.join(args.out_dir, "timing") + toast.timing.dump(alltimers, out) + + +if __name__ == "__main__": + world, procs, rank = toast.mpi.get_world() + with toast.mpi.exception_guard(comm=world): + main() diff --git a/workflows/lbt_sim.py b/workflows/lbt_sim.py new file mode 100755 index 0000000..cb4c6e2 --- /dev/null +++ b/workflows/lbt_sim.py @@ -0,0 +1,143 @@ +#!/usr/bin/env python3 +# Copyright (c) 2023-2023 by enities listed in the top-level AUTHORS file. +# Full license can be found in the top level LICENSE file. + +""" +This script creates simulated LiteBIRD TOAST detector timestreams and then uses them to +test analysis techniques. +""" + +import argparse +import os +import sys +import traceback + +import numpy as np +from astropy import units as u + +from litebirdtask import workflow + +import toast + + +def parse_config(operators, templates, comm): + """Parse command line arguments and load any config files. + + Return the final config, remaining args, and job size args. + + """ + # Argument parsing + parser = argparse.ArgumentParser(description="LiteBIRD Simulation") + + # Arguments for this workflow + parser.add_argument( + "--out_dir", + required=False, + type=str, + default=".", + help="Output directory.", + ) + + parser.add_argument( + "--debug", + required=False, + default=False, + action="store_true", + help="Make additional plots / checks for debugging", + ) + + # Build a config dictionary starting from the operator defaults, overriding with any + # config files specified with the '--config' commandline option, followed by any + # individually specified parameter overrides. + + config, args, jobargs = toast.parse_config( + parser, + operators=operators, + templates=templates, + ) + + # Create our output directory + if comm is None or comm.rank == 0: + if not os.path.isdir(args.out_dir): + os.makedirs(args.out_dir) + + # Log the config that was actually used at runtime. + outlog = os.path.join(args.out_dir, "config_log.toml") + toast.config.dump_toml(outlog, config, comm=comm) + + return config, args, jobargs + + +@toast.timing.function_timer +def main(): + env = toast.utils.Environment.get() + log = toast.utils.Logger.get() + gt = toast.timing.GlobalTimers.get() + gt.start("lbt_sim (total)") + + # Get optional MPI parameters + comm, procs, rank = toast.get_world() + + # The operators we want to configure from the command line or a parameter file. + # We will use other operators, but these are the ones that the user can configure. + # The "name" of each operator instance controls what the commandline and config + # file options will be called. + # + # We can also set some default values here for the traits, including whether an + # operator is disabled by default. + + operators = list() + templates = list() + + # Simulated observing + workflow.add_sim_observe_operators(operators) + + # Simulated data + workflow.add_sim_operators(operators) + + # Default noise model + workflow.add_simple_noise_operators(operators) + + # Pointing model + workflow.add_pointing_operators(operators) + + # Noise model + workflow.add_noise_operators(operators) + + # Mapmaking + workflow.add_mapmaking_operators(operators, templates) + + # Parse options + config, args, jobargs = parse_config(operators, templates, comm) + + # Instantiate our operators / templates that were configured from the + # command line / files + job = toast.create_from_config(config) + + # Simulate observing + + data = workflow.sim_observe(job, args, jobargs, comm) + + # Simulate data + + workflow.run_simple_models(job, args, data) + workflow.sim_data(job, args, data) + + # Processing + + workflow.select_pointing(job, args, data) + workflow.run_noise_estimation(job, args, data) + workflow.run_mapmaking(job, args, data) + + # Collect optional timing information + alltimers = toast.timing.gather_timers(comm=data.comm.comm_world) + if data.comm.world_rank == 0: + out = os.path.join(args.out_dir, "timing") + toast.timing.dump(alltimers, out) + + +if __name__ == "__main__": + world, procs, rank = toast.mpi.get_world() + with toast.mpi.exception_guard(comm=world): + main() +