Chapter 2: Survey Corps

So its been around 4 weeks into the coding period, a lot of insights and progress so far!

Profiler Class

The good news is that the Profiler class has been successfully implemented in the develop branch and will be available to users by version 0.9.30 .
Link : Profiler PR

Below is a simple example how all steps are printed based on the verbose level:

wmin = 2000
wmax = 3300
wstep = 0.01
T = 3000.0 #K
p = 0.1 #bar

sf = SpectrumFactory(wavenum_min=wmin, wavenum_max=wmax,
cutoff=0, # 1e-27,
s = sf.eq_spectrum(T)


... Scaling equilibrium linestrength
... 0.01s - Scaled equilibrium linestrength
... 0.00s - Calculated lineshift
... 0.00s - Calculate broadening HWHM
... Calculating line broadening (60869 lines: expect ~ 6.09s on 1 CPU)
...... 0.16s - Precomputed DLM lineshapes (30)
...... 0.00s - Initialized vectors
...... 0.00s - Get closest matching line & fraction
...... 0.02s - Distribute lines over DLM
...... 1.95s - Convolve and sum on spectral range
... 2.14s - Calculated line broadening
... 0.01s - Calculated other spectral quantities
... 2.21s - Spectrum calculated (before object generation)
... 0.01s - Generated Spectrum object
2.22s - Spectrum calculated

Also we can access these steps and the time taken by them using Spectrum.get_conditions()['profiler']. Also there is a parameter SpectrumFactory.profiler.relative_time_percentage that stores the percentage of time taken by each steps at a particular verbose level, helpful seeing the most expensive steps in Spectrum calculation.

Legacy Method Complexity

Several Spectrums were benchmarked against various parameters to see it’s correlation and derive its complexity. We used Profiler class with init_database() which stores all parameters of Spectrum along the Profiler in a csv generated file; all spectrum info got added into the csv file which could be used to do create visualizations to analyze the data. We used Xexplorer library and Tableau(a visual analytics platform) to create visualizations. A github repository was created to store the Visualization along the CSV data file of each benchmark.

Following are the inference of the benchmarks for Legacy Method:

• Calculation Time ∝ Number of lines
• Calculation Time ∝ Broadening max width
• Calculation Time ∝ 1/wstep
• Calculation Time not dependent on Spectral Range

So complexity of Legacy method can be derived as:
complexity = constant * Number of lines * Broadening Max Width / Wstep

LDM Method Complexity

Similar technique was used to benchmark LDM method. Now LDM uses 2 types of broadening method that are voigt and fft. voigt uses truncation for calculating spectrum in wavenmber space where as fft calculates spectrum on entire spectral range in fourier space. So benchmarks were done on both methods to compare their performance against various parameters.

Spectrum were benchmarked against parameters like Spectral Range, Wstep, Spectral Points, Number of Lines and Broadening Max Width. Following are the inferences.

For fft:
• Calculation Time ∝ Spectral Points
• Calculation Time ∝ Number of Lines

For voigt:
• Calculation Time ∝ Spectral Points
• Calculation Time ∝ Number of Lines
• Calculation Time ∝ Broadening Max Width

For LDM we are expecting the following complexity:
t_LDM_fft ~ c2*N_lines + c3*(N_G*N_L + 1)*N_v*log(N_v)
t_LDM_voigt ~ c2*N_lines + c3'*(N_G*N_L + 1)*N_truncation*log(N_truncation)

So the goal for the next 2 weeks will be to get the complexity of both voigt and fft method and see places for improving both methods and quite possibily create a Hybrid method taking the best of both worlds.