3276908917 / master Goto Github PK

This will be important for showing the world that the emulator does what an emulator ought--predict quickly.

This will primarily be a feature for the scenario processor, because all the machinery is already there. All we need to do is:

• Build a validation LHC with good minimum separation
• Request 5000 power spectra from the emu over the validation LHC
• Request 5000 power spectra from CAMB over the validation LHC
• Train a second emu to predict the deltas (or was Ariel requesting some other metric?)
• Use its output either to try to increase the accuracy of the first emu (this might require some new linking code in UI) or simply to predict what CAMB's error would be in some region of the parameter space...

LFinkbeiner_MasterThesis.tex

In particular, there's a lot of orange text pointing out ways to expand the guide even after the master's thesis is submitted.

Although the Ariel agreement is as expected, the Andrea agreement is consistently abysmal.

We have already independently verified that the Andrea and CL codes are in agreement, so there is an issue with this notebook.

user_interface.py is incomplete. We want the user to be able to provide emulator parameters in a text file (num k points, num samples, two emulator solution, etc.) which user_interface parses and acts upon.

These should be stored in the file?

The user should be able to specify these in case desired

The user should be able to input a scenario file and get an emulator out. This means we need to implement some UI scripts which will appropriately call lhc.py based on the user's specified s^* threshold!

This should automatically redirect a prediction request to one of two emulators based on the neutrino mass.

The code needs small tests to verify the accuracy of each individual component.

This will be the code that we describe in the paper. It should look like excerpts from ui and te, but should be as small as possible.

It should also contain some separate code, or at least code that we haven't yet implemented in CassL. For example, it should automatically link the massless and massive emulators under the hood.

We tried to implement square and root sampling in sigma12, but the results are preposterous--the errors are much too large.

Furthermore, we should make the code more flexible so that the user can specify a kind of sampling in any of the parameters, including combinations of them!

For example, there is a large amount of unnecessary white space throughout the code.

Many docstrings are either completely barebones, or not in a standard format. The code is therefore not user-friendly in its current state.

numpy
scipy
matplotlib
pandas
pyDOE2
GPy
camb

Maybe even jupyter and ipython?

This should involve a relatively simple feature in the scenario files which we will need to propagate throughout the entire pipeline.

• We need to support the LHC-building flags
• We need to create backup files
• We need to check if there are any backup files from which we can resume
• We need to support a two-emu solution, which will require support for two prior files, or perhaps a prior file base