def wdm_linearity(self, domain):
# Calculate dispersive terms:
if self.beta is None:
self.factor = (0.0, 0.0)
else:
if self.centre_omega is None:
self.Domega = (domain.omega - domain.centre_omega,
domain.omega - domain.centre_omega)
else:
self.Domega = (domain.omega - self.centre_omega[0],
domain.omega - self.centre_omega[1])
terms = [0.0, 0.0]
for n, beta in enumerate(self.beta[0]):
terms[0] += beta * np.power(self.Domega[0], n) / factorial(n)
for n, beta in enumerate(self.beta[1]):
terms[1] += beta * np.power(self.Domega[1], n) / factorial(n)
self.factor = (1j * fftshift(terms[0]), 1j * fftshift(terms[1]))
# Include attenuation terms if available:
if self.alpha is None:
return self.factor
else:
self.factor[0] -= 0.5 * self.alpha[0]
self.factor[1] -= 0.5 * self.alpha[1]
return self.factor
def wdm_linearity(self, domain):
# Calculate dispersive terms:
if self.beta is None:
self.factor = (0.0, 0.0)
else:
if self.centre_omega is None:
self.Domega = (domain.omega - domain.centre_omega,
domain.omega - domain.centre_omega)
else:
self.Domega = (domain.omega - self.centre_omega[0],
domain.omega - self.centre_omega[1])
terms = [0.0, 0.0]
for n, beta in enumerate(self.beta[0]):
terms[0] += beta * np.power(self.Domega[0], n) / factorial(n)
for n, beta in enumerate(self.beta[1]):
terms[1] += beta * np.power(self.Domega[1], n) / factorial(n)
self.factor = (1j * fftshift(terms[0]), 1j * fftshift(terms[1]))
# Include attenuation terms if available:
if self.alpha is None:
return self.factor
else:
self.factor[0] -= 0.5 * self.alpha[0]
self.factor[1] -= 0.5 * self.alpha[1]
return factor
def __call__(self, domain, field):
if self.ind is None:
self.ind = max(np.where(domain.nu < self.cutoff_nu)[0])
if self.field_pump is not None:
self.field_pump = ifftshift(fft(self.field_pump))
if self.dir_to_up is True:
self.field_pump[self.ind:] = 0.0
else:
self.field_pump[:self.ind] = 0.0
else:
self.field_pump = np.zeros(field.size, dtype=field.dtype)
if not (len(self.field_pump) == len(field)):
raise DiffArraysError(
"arrays of fields is different lengths")
self.field = ifftshift(fft(field))
if self.dir_to_up is True:
self.field[:self.ind] = 0.0
else:
self.field[self.ind:] = 0.0
return ifft(fftshift(self.field + self.field_pump))
def __call__(self, domain):
self.centre_omega = domain.centre_omega
self.omega = fftshift(domain.omega - domain.centre_omega)
if self.self_steepening:
self.ss_factor = 1.0 / self.centre_omega
else:
self.ss_factor = 0.0
if self.use_all:
# Require h_R in spectral domain, so take FFT of returned value:
self.h_R = fft(calculate_raman_term(domain, self.tau_1,
self.tau_2))
else:
self.h_R = 0.0
self.generate_nonlinearity()
def __call__(self, domain):
self.centre_omega = domain.centre_omega
self.omega = fftshift(domain.omega - domain.centre_omega)
if self.self_steepening:
self.ss_factor = 1.0 / self.centre_omega
else:
self.ss_factor = 0.0
if self.use_all:
# Require h_R in spectral domain, so take FFT of returned value:
self.h_R = fft(calculate_raman_term(
domain, self.tau_1, self.tau_2))
else:
self.h_R = 0.0
self.generate_nonlinearity()
def default_linearity(self, domain):
# Calculate dispersive terms:
if self.beta is None:
self.factor = 0.0
else:
if self.centre_omega is None:
self.Domega = domain.omega - domain.centre_omega
else:
self.Domega = domain.omega - self.centre_omega
# Allow general dispersion:
terms = 0.0
for n, beta in enumerate(self.beta):
terms += beta * np.power(self.Domega, n) / factorial(n)
self.factor = 1j * fftshift(terms)
# Include attenuation term if available:
if self.alpha is None:
return self.factor
else:
self.factor -= 0.5 * self.alpha
return self.factor
def default_linearity(self, domain):
# Calculate dispersive terms:
if self.beta is None:
self.factor = 0.0
else:
if self.centre_omega is None:
self.Domega = domain.omega - domain.centre_omega
else:
self.Domega = domain.omega - self.centre_omega
# Allow general dispersion:
terms = 0.0
for n, beta in enumerate(self.beta):
terms += beta * np.power(self.Domega, n) / factorial(n)
self.factor = 1j * fftshift(terms)
# Include attenuation term if available:
if self.alpha is None:
return self.factor
else:
self.factor -= 0.5 * self.alpha
return self.factor
def __call__(self, domain, field):
self.Domega = domain.omega - domain.centre_omega
self.factor = 1j * fftshift(self.time * self.Domega)
return ifft(np.exp(self.factor) * fft(field))
