Printer Friendly

pyLLE: A Fast and User Friendly Lugiato-Lefever Equation Solver.

1. Introduction

The Lugiato-Lefever Equation (LLE), first developed to provide a description of spatial dissipative structures in optical systems [1], has recently made a significant impact in the integrated photonics community, where it has been adopted to help understand and predict Kerr- mediated nonlinear optical phenomena such as parametric frequency comb generation [2, 3] inside microresonators [4-6]. The LLE is essentially an application of the nonlinear Schrodinger equation (NLSE) [7] to a damped, driven Kerr nonlinear resonator, so that a periodic boundary condition is applied. Importantly, a slow-varying time envelope is stipulated, resulting in a mean-field solution in which the field does not vary within a round trip. This constraint, which differentiates the LLE from the more general Ikeda map [8], significantly simplifies calculations while still providing excellent physical representation for a wide variety of systems. In particular, simulations based on the LLE formalism have enabled modeling that quantitatively agrees with reported experimental results on microcomb generation [9, 10] (e.g., in terms of spectral bandwidth), and have also been central to theoretical studies that have provided better insight into novel nonlinear dynamics that can be supported by Kerr nonlinear microresonators [11-13].

The great potential of microresonator frequency combs (microcombs) in a wide variety of applications [3, 14-22] suggests the need for efficient and widely accessible computational tools to more rapidly further their development. Although LLE simulations are commonly performed by research groups working in the field, to our knowledge no free software package for solving this equation in an easy and fast way is currently available. Here, we introduce pyLLE, an open-source LLE solver for microcomb modeling. It combines the user-friendliness of the Python programming language and the computational power of the Julia programming language.

2. Software Specifications
NIST Operating Unit    Physical Measurement Laboratory,
                       Microsystems and Nanotechnology Division
Category               Lugiato Lefever Equation Solver
Targeted Users         Scientist / Researcher / Engineer in
                       Photonics/Metrology
Operating Systems      Windows/Linux/MacOS
Programming Language   Python>3.4, Julia 0.6.4
Inputs/Outputs         Input text file with resonator dispersion;
                       output electric field data
Documentation          https://usnistgov.github.io/pyLLE/
Accessibility          N/A
Disclaimer             https://www.nist.gov/director/licensing


3. Lugiato-Lefever Equation Model

The Lugiato-Lefever equation is derived from the nonlinear Schrodinger equation, which can be written, if considering only the third order nonlinearity and in the reference frame moving with the group velocity, as:

[mathematical expression not reproducible] (1)

with E (z, [tau]) being the complex electric field propagating along z during the time [tau], [alpha] the loss per unit length, [gamma] = [n.sub.2][[omega].sub.0]/([c.sub.0][A.sub.eff]) the effective nonlinear coefficient, [n.sub.2] is the Kerr nonlinear coefficient (i.e., the nonlinear refractive index), [[omega].sub.0] the angular frequency of nearest mode close to the pump frequency [[omega].sub.pmp], [A.sub.eff] the effective mode area in the resonator at the pump frequency, [[beta].sub.k] is the kth-order Taylor expansion coefficient of the dispersion [7], and [c.sub.0] the speed of light in vacuum.

Next, we assume a geometry such as the one described in Fig. 1, where light injected into an optical waveguide is coupled into a traveling wave resonator (such as a ring or disk, for instance). Hence, a periodic condition for each round trip needs to be introduced, which leads to the coupled equations used to solve the Ikedamap [8]:

[mathematical expression not reproducible] (2)

[mathematical expression not reproducible] (3)

where [E.sup.(m)] represents the field in the resonator for the mth round trip, [[phi].sub.0] the phase shift accumulated during a single round trip, L = 2[pi]R the length of the resonator and [theta]the resonator-waveguide coupling coefficient.

We then make a key assumption, that of a slowly-varying field envelope, so that little non-linear physics happens during a single round trip. This assumption implies the possibility to average Eqs. (2) and (3) over one round trip, leading to the LLE:

[mathematical expression not reproducible] (4)

with t being the slow time and [tau] the fast time (i.e -[t.sub.R]/2 [less than or equal to] [tau] [less than or equal to] [t.sub.R]/2), [t.sub.R] the round trip time, [alpha]' = [alpha]L + [theta] are the total round trip losses in the cavity and [[delta].sub.0] = [[omega].sub.pmp] - [[omega].sub.0] the detuning of the pump field with respect to the closest cold-cavity resonance [[omega].sub.0].

For systems with a complex dispersion profile, such as microring resonators, instead of using a Taylor expansion of the dispersion that results in a set of different [beta] coefficients (i.e., dispersion to different orders), it is often more convenient and accurate to work with the integrated dispersion [D.sub.int] = [[omega].sub.[mu]] - ([[omega].sub.0] + [D.sub.1][mu]), with [mu] an integer representing the mode number relative to the pump resonance (for which [mu] = 0), [[omega].sub.[mu]] is the angular frequency of the [mu]th mode, and [D.sub.1] is the angular free-spectral range evaluated at the pumped resonance (i.e., [D.sub.1] /2[pi] is the free-spectral range in units of Hz). This implies that one has to work in the frequency domain. Considering the approximation of the slowly-varying envelope, one can consider the Fourier transform, FT, and inverse Fourier transform, [FT.sup.-1], relative to the fast time [tau]. Hence, Eq. (4) becomes the one implemented in the package presented here:

[mathematical expression not reproducible] (5)

This approach is similar to the one found in Hansson and Wabnitz [8], for simulating the Kerr dynamics across a large number of modes using the Coupled Mode Theory (CMT) formalism. It is convenient indeed to work in the frequency domain, as it avoids the approximation of truncating the dispersion beyond a certain order, and the resonance frequencies can be found accurately using a Maxwell's equation eigenvalue solver. Moreover, working in the frequency domain allows the use of well- developed computational libraries for executing the Fourier transform operation in one iteration of the split-step Fourier technique, and is the approach implemented in the pyLLE package.

4. pyLLE Description

4.1 Introduction to pyLLE

Several approaches for solving the complex field of a multi-mode resonator have been studied, including Coupled Mode Theory (CMT) and the LLE. However, the LLE provides a temporal approach which is well suited to study Kerr non-linear resonators, especially in the context of soliton microcombs. Our fundamental goal in the pyLLE package is to provide a fast, efficient, platform-independent and freely available tool for simulating the LLE, to enable researchers with interest in microcombs to simulate their behavior without requiring in-depth knowledge of the LLE formalism or its numerical implementation.

The bulk of the computation is done through the Julia back-end. The Julia language provides an efficient computational interface with BLAS (basic linear algebra subprograms), enabling reuse of the same Fast Fourier Transform plan (i.e plan_fft) throughout several iterations of a loop, resulting in an overall simulation that lasts only a few minutes. Python provides complementary functionality, with easy scripting, display of figures, and saving of results.

To assess the performance of the solver, we perform the same simulation of a Si3N4 ring resonator (described in more detail in the documentation of Ref. [23]) using fixed hardware (a commercial laptop, the MacBook Pro 2017 3.1 GHz Intel Core i5, RAM 16 GB 2133 MHz LPDDR3) and three different software implementations, pyLLE, a pure Python version, and Matlab-based code. (1) We find that the simulation, in which the field behavior across 244 modes of the resonator is calculated, is four times faster using pyLLE than the pure Python approach, and almost twice as fast as a Matlab solver (Table 1). We note that Matlab has a proprietary license, compared to the open-source pyLLE package.

As mentioned above, pyLLE is not only fast but highly user-friendly, thanks to the Python language which is becoming an increasingly valuable resource in the scientific toolbox. Below we describe a full example of how to use pyLLE, which consists ultimately of only a few lines of code. The complete example is accessible online [23].

4.2 Example of pyLLE Use

In this section, we step through an example of how a simulation is set up and executed in pyLLE. We assume the pyLLE package has been installed on the user local machine following the instructions available in Ref. [23].

4.2.1 Setting up pyLLE

Let's start by importing the package:
import pyLLE

One has to define the resonator parameters.

res = {'R': 23e-6, # ring radius in meters
      'Qi' :1e6,   # Intrinsic Q factor
      'Qc': 1e6,   # Coupling Q factor
      'y':  1.55,  # Effective nonlinear coefficient at the
                     pump frequency
                     (units of [W.sup.-1] [m.sup.-1])
      'dispfile': 'TestDispersion.txt',
}


The parameters in the code above are mostly self-explanatory and are chosen to fit the physical device investigated. The dispfile parameter should be a raw text file, without header, in a "comma separated value" (csv) format consisting of the integer azimuthal mode orders and corresponding resonance frequencies (in Hz) as the first and second column, respectively. Importantly, the parameter names are the ones commonly used in the LLE formalism, hence some follow the Greek alphabet. To improve the usability of pyLLE, one can define a parameter either by its Greek symbol or through its Latin name (e.g one can use either [gamma] or gamma).

The next step is to define the simulation parameters through the dictionary:
import numpy as np
sim = {'Pin': 150e-3,                    # Input power in W
      'Tscan': 1e6,                      # Simulation length in units
                                           of number of round trips
      'f_pmp': 191e12,                   # Pump Frequency in Hz
      '[delta][omega]_init': 2e9*2*np.pi,# Initial detuning of the
                                           pump in rad/s
      '[delta][omega]_end': -8e9*2*np.pi,# End detuning of the pump in
                                           rad/s
      '[mu]_sim': [-74,170],             # Azimuthal mode numbers to
                                           simulate in the LLE on the
  left and right side of the pump
      '[mu]_fit': [-71,180],             # Azimuthal mode number range
                                           to fit the dispersion on
  the left and right side of the pump
      }


In the parameters described above, one specifies a simulation with pump power Pin in the input coupling bus waveguide of 150 mW, with a linear detuning ramp of the pump from init to [delta][omega]-end relative to the pump mode angular frequency, i.e., the mode closest to the defined pump frequency f-pmp. The simulation length Tscan is in units of number of round trips, as is most convenient in the LLE formalism. Two parameter ranges for the simulation frequency range have to be defined, [mu]_fit, which determines the fit window for the raw data found in dispfile, and [mu]_sim which is the number of modes simulated in the LLE. [mu]_sim can differ from [mu]_fit (i.e., the simulation can be performed over a truncated range or can be expanded over a larger range through extrapolation).

Once the resonator and simulation parameters are set, one can easily instantiate the pyLLE class:

solver = pyLLE.LLEsolver(sim=sim,res=res)

4.2.2 Dispersion Analysis

To plot and retrieve all the dispersion data, the method solver.Analyze has to be called, resulting in the plot of the integrated dispersion [D.sub.int], and returning the handle of the figure (and axes if using matplotlib).

In Fig. (2), one extrapolates (orange curve - fit dispersion) outside of the spectral window containing the raw dispersion data (green circles), to enable a simulation over a broader spectral range (blue dashed line). One has to be careful about using this extrapolation feature, to make sure that the extrapolated dispersion is a reasonable physical representation of the dispersion. For example, extrapolation can result in ripples in the integrated dispersion, creating zero-crossings that are artifacts that will influence the LLE simulation results.

4.2.3 Temporal Simulation

The core function of pyLLE is to solve the full temporal Lugiato-Lefever Equation as described in Eq. (5). The solver implemented in this package is based on a Julia core called from python. To interface both languages easily, a .hdf5 file is created in a temporary location with all the necessary data to solve the LLE.

We first set up the solver:

solver.Setup()

After which we call the temporal solver :

solver.SolveTemporal()

A progress bar has been implemented which displays the state of the current simulation, making it convenient to assess the time a simulation will take and when it is complete. To process the data through python, one has to retrieve the Julia data using the method:

solver.RetrieveData()

The pyLLE class includes methods to ease the plotting process. The solver.PlotCombPower method (Fig. 3) provides an overview of the microcomb behavior, plotting the spectra, time envelope, and comb power inside the resonator for the different steps of the LLE, which are sub- sampled for faster display.

To obtain a better idea of the microcomb behavior for a given laser-cavity mode detuning, we plot the spectrum (Fig. 4) and the temporal profile (Fig. 5) of the electric field in the resonator at a fixed LLE step:

The temporal profile can also be retrieved, which can be interesting, for example, in the case when we are on a soliton state for the given detuning, and by comparing the position of the soliton relative to the origin of time which is linked to the soliton drift:

4.2.4 Steady-state Simulation

Instead of solving the full temporal LLE in Eq. (5), we can instead consider solutions to the steady-state LLE, i.e., considering the right-hand side of Eq. (5) equal to zero. Steady- state solutions to the LLE indicate what types of states are supported by the system, but do not necessarily give an indication of how to access such states in practice.

Newton's method can be used to find steady-state solutions and is implemented in the method solver.SolveSteadyState. Although it gives fast results, the accuracy of such a solver remains questionable compared to a full temporal resolution of the equation (in particular, the convergence of the Newton's method is not always assured).

To run the steady-state solver, one has to set it up in the same way as in the temporal method (see sections 4.2.1 to 4.2.2), i.e., defining the two dictionaries res and sim as in the example above, and calculating the dispersion profile. Here it is not necessary to use the method solver.Setup, as the Newton's method places relatively low computational demands and thus everything is solved with Python.

However, the main difference with respect to the temporal solver is the introduction of a fixed detuning [lambda][omega] of the pump relative to the closest mode, so that:

solver.sim ['[lambda][omega]'] = -5e9*2*np.pi # this value corresponds to the detuning at the end of the soliton step in the temporal simulation

The results of the steady-state Newton's method solver, with the function call indicated below, produces the spectrum shown in Fig. 6 and returns the figure handle:

5. pyLLE Module Description

5.1 _llesolver.py

5.1.1 MyLogger(self, fname)

Helper class for logging the results

5.1.2 Latexify(self, **kwarg)

Class that handles saving the figures in a nice way compatible with the column/page size of different latex templates.

* Input ([] = optional):

--figname = name to save the figure (without extension)

--fig = matplotlib handle to the figure

--[fig_width]: default = '1column'

--[frmt]: default = 'pdf'

--[fig_height] : default = 6.5

--[font_size] : default = 8

5.1.3 LLEsolver(self, **kwargs)

Class to solve the LLE Initialization input ([] = optional):

* res <dict>

--Qi <float>: intrinsic Q of the resonator

--Qc <float>: coupling Q of the resonator

--R <float> : ring radius

--gamma <float>: Effective non-linearity of the waveguide comprising the resonator.

--dispfile <str> : str pointing to a .csv file where the azimuthal mode orders and corresponding resonance frequencies are saved

* sim <dict>

--Tscan <float>: length of the simulation (in units of round trip)

--mufit <list>: number of modes to fit

--mu_sim <list>: number of mode that were simulated

--domega_init <float>: initial detuning of the pump

--domega_end <float>: final detuning of the pump

- [domga_stop] <float>: where to stop the scan in detuning but keep doing the simulation

* debug <bool>: Save a trace in a log file in the working directory of the different actions pyLLE perform (default = True)

LLEsolver.Analyze(self, plot=False, f=None, ax=None, label=None, plottype='all', zero_lines=True, mu_sim=None)

Call pyLLE.analyzedisp.AnalyzeDisp to get the dispersion of the resonator we want to simulate LLEsolver.Setup(self)

Set up the simulation for the Julia back-end. Save the two main dictionaries self.sim and self.res into a readable hdf5 file for Julia in the temporary location defined by the operating system.

LLEsolver.SolveTemporal(self, tol=0.001, maxiter=6, step_factor=0.1)

Call Julia to solve the LLE

LLEsolver.SolveSteadyState(self)

Newton-Raphson method to find the root of the steady state equation

LLEsolver.RetrieveData(self)

Load the output hdf5 saved by Julia and transform it into a user-friendly dictionary to be more suited for use with Python

LLEsolver.PlotCombPower(self, do_matplotlib=False)

Plot a figure with 3 subplots.

* Top subplot = map of the spectra for the steps taken by the LLE (step sub- sampled to be 1000)

* Middle subplot = temporal map of the intensity inside the resonator for the steps of the LLE

* Bottom subplot = normalized comb power

* Output

--f <obj>: matplotlib/plotly figure handle

--ax <obj>: matplotlib axes handle (if plotly, only returns f)

LLEsolver.PlotCombSpectra(self, ind, f=None, ax=None, label=None, pwr='both', do_matplotlib=False, plot=True)

Plot the spectrum for a given index in the 1000 sub-sampled LLE steps

* Input

--ind <ind>: index in the LLE step for which the spectrum will be plotted

--f <obj>: matplotlib figure handle (if None, new figure)

--ax < obj> : matplotlib axes handle

--label <str>: label for the legend

--pwr <str>: 'both', 'ring', 'wg' depending on the spectra wanted (inside the ring, the waveguide, or both)

* Output

--freq <numpy.array>: frequency in Hz

--Sout <numpy.array>: spectral density of power in the waveguide (dBm)

--Sring <numpy.array>: spectral density of power in the ring (dBm)

--f < obj >: matplotlib/plotly figure handle

--ax <obj>: matplotlib axes handle (if plotly, only returns f)

LLEsolver.PlotSolitonTime(self, ind, f=None, ax=None, label=None, do_matplotlib=False)

Plot the spectra for a given index in the 1000 sub-sampled LLE step

* Input

--ind <ind>: index in the LLE step to plot the spectra

--f <obj>: matplotlib figure handle (if None, new figure)

--ax < obj > : matplotlib axe handle

--label <str>: label for the legend

* Output

--[tau] <obj>: Time in the resonator

--U <numpy.array>: Temporal electric field for the given step of the LLE

--f < obj >: matplotlib/plotly figure handle

--ax <obj>: matplotlib axes handle (if plotly, only returns f)

LLEsolver.SaveResults(self, fname, path='./') Save the whole class using the pickle package, which makes it easy to load back the saved results

* Input

--fname <str>: name to save. The '.pkl' extension will be added

--path <str>: path to save the results (defaults './')

5.2 _analyzedisp

5.2.1 AnalyzeDisp(self, **kwargs)

Call to analyze the dispersion of a simulated resonator. Initialization input. Everything is in SI ([]=optional):

* Input:

--f_center <float>: pump frequency

--file <str>: .txt file to load

--R <float>: radius of the resonator

--rM_fit <list>.: lower and upper bounds of mode to fit the dispersion

--rMsim <list>.: lower and upper bounds of the modes to extrapolate for the simulation

--f < obj >: matplotlib figure handle

--ax < obj > : matplotlib axes handle

--label <list>: list of the string for each plot to be labeled

--plottype <str>: define the type of plot 'all' [defaults], 'sim', 'fit', 'fem', 'ind'

AnalyzeDisp.GetDint(self) Retrieve the dispersion of a resonator based on the frequency of resonance and azimuthal mode order. The data are fit using a cubic spline method

* Output:

--self.PrMfit: scipy.interpolate object which fitted the data

--self.Dintfit: fitted integrated dispersion for the simulated mode

--self.neff_pmp: effective index at the pump frequency

--self.ng_pmp: group index at the pump frequency

Key words: Julia; micro-combs, non-linear optics; python.

Acknowledgments

The authors acknowledge funding support from the DARPA DODOS and ACES programs, the NIST-on-a-chip program, and the Cooperative Research Agreement between the University of Maryland and NIST-CNST (award no. 70NANB10H193). They also thank Dr. Su-Peng Yu and Dr. Jared H. Strait for their helpful comments on the manuscript.

6. References

[1] Lugiato LA, Lefever R (1987) Spatial Dissipative Structures in Passive Optical Systems. Physical Review Letters 58(21):2209--2211. https://doi.org/10.1103/PhysRevLett.58.2209

[2] Del'Haye P, Schliesser A, Arcizet O, Wilken T, Holzwarth R, Kippenberg TJ (2007) Optical frequency comb generation from a monolithic microresonator. Nature 450(7173):1214-1217. https://doi.org/10.1038/nature06401

[3] Kippenberg TJ, Gaeta AL, Lipson M, Gorodetsky ML (2018) Dissipative kerr solitons in optical microresonators. Science 361(6402):eaan8083. https://doi.org/10.1126/science.aan8083

[4] Coen S, Randle HG, Sylvestre T, Erkintalo M (2012) Modeling of octave- spanning Kerr frequency combs using a generalized mean-field Lugiato-Lefever model. Optics Letters 38(1):37-39. https://doi.org/10.1364/ol.38.000037

[5] Chembo YK, Menyuk CR (2013) Spatiotemporal Lugiato-Lefever formalism for Kerr-comb generation in whispering-gallery-mode resonators. Physical Review A 87(5):053852-053854. https://doi.org/10.1103/PhysRevA.87.053852

[6] Lamont MRE, Okawachi Y, Gaeta AL (2013) Route to stabilized ultrabroadband microresonator-based frequency combs. Optics Letters 38(18):3478-3481. https://doi.org/10.1364/OL.38.003478

[7] Agrawal GP (2007) Nonlinear Fiber Optics (Academic Press) 4th Ed. https://doi.org/10.1016/b978-0-12-369516-1.x5000-6

[8] Hansson T, Wabnitz S (2015) Frequency comb generation beyond the Lugiato- Lefever equation: multi-stability and super cavity solitons. Journal of the Optical Society of America B 32(7):1259-1266. https://doi.org/10.1364/JOSAB.32.001259

[9] Xue X, Xuan Y, Liu Y, Wang PH, Chen S, Wang J, ELeaird D, Qi M, Weiner A (2015) Mode-locked dark pulse Kerr combs in normal-dispersion microresonators. Nature Photonics 9:594-600. https://doi.org/10.1038/nphoton.2015.137

[10] Li Q, Briles TC, Westly DA, Drake TE, Stone JR, Ilic BR, Diddams SA, Papp SB, Srinivasan K (2017) Stably accessing octave-spanning microresonator frequency combs in the soliton regime. Optica 4(2):193-203. https://doi.org/10.1364/0PTICAA000193

[11] Kozyreff G (2012) Localized Turing patterns in nonlinear optical cavities. Physica D: Nonlinear Phenomena 241(10):939-946. https://doi.org/10.1016Zj.physd.2012.02.007

[12] Luo R, Liang H, Lin Q (2016) Multicolor cavity soliton. Optics Express 24(15):16777-16787. https://doi.org/10.1364/0E.24.016777

[13] Moille G, Li Q, Kim S, Westly D, Srinivasan K (2018) Phased-locked two- color single soliton microcombs in dispersion-engineered Si3N4 resonators. Optics Letters 43(12):2772-2775. https://doi.org/10.1364/0L.43.002772

[14] Papp SB, Beha K, Del'Haye P, Quinlan F, Lee H, Vahala KJ, Diddams SA (2014) Microresonator frequency comb optical clock. Optica 1(1):10. https://doi.org/10.1364/0PTICA.L000010

[15] Suh MG, Yang QF, Yang KY, Yi X, Vahala KJ (2016) Microresonator soliton dual-comb spectroscopy. Science 354(6312):600-603. https://doi.org/10.1126/science.aah6516

[16] Marin-Palomo P, Kemal JN, Karpov M, Kordts A, Pfeifle J, Pfeiffer MHP, Trocha P, Wolf S, Brasch V, Anderson MH, Rosenberger R, Vijayan K, Freude W, Kippenberg TJ, Koos C (2017) Microresonator- based solitons for massively parallel coherent optical communications. Nature 546(7657):274-279. https://doi.org/10.1038/nature22387

[17] Spencer DT, Drake T, Briles TC, Stone J, Sinclair LC, Fredrick C, Li Q, Westly D, Ilic BR, Bluestone A, Volet N, Komljenovic T, Chang L, Lee SH, Oh DY, Suh MG, Yang KY, Pfeiffer MHP, Kippenberg TJ, Norberg E, Theogarajan L, Vahala K, Newbury NR, Srinivasan K, Bowers JE, Diddams SA, Papp SB (2018) An optical-frequency synthesizer using integrated photonics. Nature 557(7703):81-85. https://doi.org/10.1038/s41586-018-0065-7

[18] Trocha P, Karpov M, Ganin D, Pfeiffer MHP, Kordts A, Wolf S, Krockenberger J, Marin-Palomo P, Weimann C, Randel S, Freude W, Kippenberg TJ, Koos C (2018) Ultrafast optical ranging using microresonator soliton frequency combs. Science 359(6378):887-891. https://doi.org/10.1126/science.aao3924

[19] Suh MG, Vahala KJ (2018) Soliton microcomb range measurement. Science 359(6378):884-887. https://doi.org/10.1126/science.aao1968

[20] Dutt A, Joshi C, Ji X, Cardenas J, Okawachi Y, Luke K, Gaeta AL, Lipson M (2018) On-chip dual-comb source for spectroscopy. Science Advances 4(3):e1701858. https://doi.org/10.1126/sciadv.1701858

[21] Obrzud E, Rainer M, Harutyunyan A, Anderson MH, Liu J, Geiselmann M, Chazelas B, Kundermann S, Lecomte S, Cecconi M, Ghedina A, Molinari E, Pepe F, Wildi F, Bouchy F, Kippenberg TJ, Herr T (2019) A microphotonic astrocomb. Nature Photonics 13(1):31-35. https://doi.org/10.1038/s41566-018-0309-y

[22] Suh MG, Yi X, Lai YH, Leifer S, Grudinin IS, Vasisht G, Martin EC, Fitzgerald MP, Doppmann G, Wang J, Mawet D, Papp SB, Diddams SA, Beichman C, Vahala K (2019) Searching for exoplanets using a microresonator astrocomb. Nature Photonics 13(1):25-30. https://doi.org/10.1038/s41566-018-0312-3

[23] pyLLE: a Fast and User Friendly Lugiato-Lefever Equation Solver, National Institute of Standards and Technology. Available at https://github.com/usnistgov/pyLLE

Gregory Moille, Qing Li, and Xiyuan Lu are guest research associates in the Microsystems and Nanotechnology Division at NIST, and are postdoctoral scholars at the University of Maryland. Kartik Srinivasan is a physicist in the Microsystems and Nanotechnology Division at NIST and an adjunct professor at the University of Maryland. The National Institute of Standards and Technology is an agency of the U.S. Department of Commerce.

Gregory Moille (1,2), Qing Li (1,2,3), Xiyuan Lu (1,2), Kartik Srinivasan (1,4)

(1) National Institute of Standards and Technology, Gaithersburg, MD 20899 USA

(2) Institute for Research in Electronics and Applied Physics and Maryland Nanocenter, University of Maryland, College Park, Maryland 20742 USA

(3) Electrical and Computer Engineering, Carnegie Mellon University, Pittsburgh, PA 15213 USA

(4) Joint Quantum Institute, NIST/University of Maryland, College Park, Maryland 20742 USA

gregory.moille@nist.gov

kartik.srinivasan@nist.gov

Software DOI: https://doi.org/10.18434/M32059

Software Version: 2.1

Accepted: April 29, 2019

Published: May 24, 2019

https://doi.org/10.6028/jres.124.012

(1) Certain commercial items are identified in this paper to foster understanding. Such identification does not imply recommendation or endorsement by NIST, nor does it imply that the items identified are necessarily the best available for the purpose.

Caption: Fig. 1. Cartoon of a ring resonator coupled to a waveguide where a continuous wave pump is sent as an input and produces, through [[chi].sup.(3)]-mediated nonlinear interactions in the ring, a frequency comb at the output. The coupling coefficient from the waveguide to the ring and vice-versa is [theta] and the intrinsic resonator losses per unite of length is [alpha].

Caption: Fig. 2. Integrated dispersion retrieved through the dispfile file, with the raw values from the file (green circles), fit dispersion (orange solid line), and integrated dispersion that will be used in the solver (blue dashed line).

Caption: Fig. 3. (a) Comb spectra vs. LLE step. (b) Temporal envelope of the electromagnetic field vs. LLE step. (c) Comb power (blue) vs. LLE step. The pump detuning during the simulation (orange) is also plotted.

Caption: Fig. 4. Spectrum of the soliton comb obtained at the LLE step = 570, inside the resonator (orange), and out-coupled into the access waveguide (blue).

Caption: Fig. 5. Electromagnetic envelope of the time-domain profile of a single soliton state inside the resonator.

Caption: Fig. 6. Result of a steady-state simulation of the comb spectrum within the resonator (orange) and out-coupled into the access waveguide (blue).
Table 1. Performance comparison of the same resonator LLE
simulation using three different software implementations.

Matlab 2018a      Pure Python    pyLLE

19 mins             45 min      11 mins
COPYRIGHT 2019 National Institute of Standards and Technology
No portion of this article can be reproduced without the express written permission from the copyright holder.
Copyright 2019 Gale, Cengage Learning. All rights reserved.

Article Details
Printer friendly Cite/link Email Feedback
Author:Moille, Gregory; Li, Qing; Lu, Xiyuan; Srinivasan, Kartik
Publication:Journal of Research of the National Institute of Standards and Technology
Article Type:Report
Geographic Code:1USA
Date:Jan 1, 2019
Words:4662
Previous Article:A Reference Schema for the Unit Manufacturing Process Information Model.
Next Article:Scatter Corrections in X-Ray Computed Tomography: A Physics-Based Analysis.
Topics:

Terms of use | Privacy policy | Copyright © 2019 Farlex, Inc. | Feedback | For webmasters