|
|
""" |
|
|
This module has all the classes and functions related to waves in optics. |
|
|
|
|
|
**Contains** |
|
|
|
|
|
* TWave |
|
|
""" |
|
|
|
|
|
__all__ = ['TWave'] |
|
|
|
|
|
from sympy.core.basic import Basic |
|
|
from sympy.core.expr import Expr |
|
|
from sympy.core.function import Derivative, Function |
|
|
from sympy.core.numbers import (Number, pi, I) |
|
|
from sympy.core.singleton import S |
|
|
from sympy.core.symbol import (Symbol, symbols) |
|
|
from sympy.core.sympify import _sympify, sympify |
|
|
from sympy.functions.elementary.exponential import exp |
|
|
from sympy.functions.elementary.miscellaneous import sqrt |
|
|
from sympy.functions.elementary.trigonometric import (atan2, cos, sin) |
|
|
from sympy.physics.units import speed_of_light, meter, second |
|
|
|
|
|
|
|
|
c = speed_of_light.convert_to(meter/second) |
|
|
|
|
|
|
|
|
class TWave(Expr): |
|
|
|
|
|
r""" |
|
|
This is a simple transverse sine wave travelling in a one-dimensional space. |
|
|
Basic properties are required at the time of creation of the object, |
|
|
but they can be changed later with respective methods provided. |
|
|
|
|
|
Explanation |
|
|
=========== |
|
|
|
|
|
It is represented as :math:`A \times cos(k*x - \omega \times t + \phi )`, |
|
|
where :math:`A` is the amplitude, :math:`\omega` is the angular frequency, |
|
|
:math:`k` is the wavenumber (spatial frequency), :math:`x` is a spatial variable |
|
|
to represent the position on the dimension on which the wave propagates, |
|
|
and :math:`\phi` is the phase angle of the wave. |
|
|
|
|
|
|
|
|
Arguments |
|
|
========= |
|
|
|
|
|
amplitude : Sympifyable |
|
|
Amplitude of the wave. |
|
|
frequency : Sympifyable |
|
|
Frequency of the wave. |
|
|
phase : Sympifyable |
|
|
Phase angle of the wave. |
|
|
time_period : Sympifyable |
|
|
Time period of the wave. |
|
|
n : Sympifyable |
|
|
Refractive index of the medium. |
|
|
|
|
|
Raises |
|
|
======= |
|
|
|
|
|
ValueError : When neither frequency nor time period is provided |
|
|
or they are not consistent. |
|
|
TypeError : When anything other than TWave objects is added. |
|
|
|
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy import symbols |
|
|
>>> from sympy.physics.optics import TWave |
|
|
>>> A1, phi1, A2, phi2, f = symbols('A1, phi1, A2, phi2, f') |
|
|
>>> w1 = TWave(A1, f, phi1) |
|
|
>>> w2 = TWave(A2, f, phi2) |
|
|
>>> w3 = w1 + w2 # Superposition of two waves |
|
|
>>> w3 |
|
|
TWave(sqrt(A1**2 + 2*A1*A2*cos(phi1 - phi2) + A2**2), f, |
|
|
atan2(A1*sin(phi1) + A2*sin(phi2), A1*cos(phi1) + A2*cos(phi2)), 1/f, n) |
|
|
>>> w3.amplitude |
|
|
sqrt(A1**2 + 2*A1*A2*cos(phi1 - phi2) + A2**2) |
|
|
>>> w3.phase |
|
|
atan2(A1*sin(phi1) + A2*sin(phi2), A1*cos(phi1) + A2*cos(phi2)) |
|
|
>>> w3.speed |
|
|
299792458*meter/(second*n) |
|
|
>>> w3.angular_velocity |
|
|
2*pi*f |
|
|
|
|
|
""" |
|
|
|
|
|
def __new__( |
|
|
cls, |
|
|
amplitude, |
|
|
frequency=None, |
|
|
phase=S.Zero, |
|
|
time_period=None, |
|
|
n=Symbol('n')): |
|
|
if time_period is not None: |
|
|
time_period = _sympify(time_period) |
|
|
_frequency = S.One/time_period |
|
|
if frequency is not None: |
|
|
frequency = _sympify(frequency) |
|
|
_time_period = S.One/frequency |
|
|
if time_period is not None: |
|
|
if frequency != S.One/time_period: |
|
|
raise ValueError("frequency and time_period should be consistent.") |
|
|
if frequency is None and time_period is None: |
|
|
raise ValueError("Either frequency or time period is needed.") |
|
|
if frequency is None: |
|
|
frequency = _frequency |
|
|
if time_period is None: |
|
|
time_period = _time_period |
|
|
|
|
|
amplitude = _sympify(amplitude) |
|
|
phase = _sympify(phase) |
|
|
n = sympify(n) |
|
|
obj = Basic.__new__(cls, amplitude, frequency, phase, time_period, n) |
|
|
return obj |
|
|
|
|
|
@property |
|
|
def amplitude(self): |
|
|
""" |
|
|
Returns the amplitude of the wave. |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy import symbols |
|
|
>>> from sympy.physics.optics import TWave |
|
|
>>> A, phi, f = symbols('A, phi, f') |
|
|
>>> w = TWave(A, f, phi) |
|
|
>>> w.amplitude |
|
|
A |
|
|
""" |
|
|
return self.args[0] |
|
|
|
|
|
@property |
|
|
def frequency(self): |
|
|
""" |
|
|
Returns the frequency of the wave, |
|
|
in cycles per second. |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy import symbols |
|
|
>>> from sympy.physics.optics import TWave |
|
|
>>> A, phi, f = symbols('A, phi, f') |
|
|
>>> w = TWave(A, f, phi) |
|
|
>>> w.frequency |
|
|
f |
|
|
""" |
|
|
return self.args[1] |
|
|
|
|
|
@property |
|
|
def phase(self): |
|
|
""" |
|
|
Returns the phase angle of the wave, |
|
|
in radians. |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy import symbols |
|
|
>>> from sympy.physics.optics import TWave |
|
|
>>> A, phi, f = symbols('A, phi, f') |
|
|
>>> w = TWave(A, f, phi) |
|
|
>>> w.phase |
|
|
phi |
|
|
""" |
|
|
return self.args[2] |
|
|
|
|
|
@property |
|
|
def time_period(self): |
|
|
""" |
|
|
Returns the temporal period of the wave, |
|
|
in seconds per cycle. |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy import symbols |
|
|
>>> from sympy.physics.optics import TWave |
|
|
>>> A, phi, f = symbols('A, phi, f') |
|
|
>>> w = TWave(A, f, phi) |
|
|
>>> w.time_period |
|
|
1/f |
|
|
""" |
|
|
return self.args[3] |
|
|
|
|
|
@property |
|
|
def n(self): |
|
|
""" |
|
|
Returns the refractive index of the medium |
|
|
""" |
|
|
return self.args[4] |
|
|
|
|
|
@property |
|
|
def wavelength(self): |
|
|
""" |
|
|
Returns the wavelength (spatial period) of the wave, |
|
|
in meters per cycle. |
|
|
It depends on the medium of the wave. |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy import symbols |
|
|
>>> from sympy.physics.optics import TWave |
|
|
>>> A, phi, f = symbols('A, phi, f') |
|
|
>>> w = TWave(A, f, phi) |
|
|
>>> w.wavelength |
|
|
299792458*meter/(second*f*n) |
|
|
""" |
|
|
return c/(self.frequency*self.n) |
|
|
|
|
|
|
|
|
@property |
|
|
def speed(self): |
|
|
""" |
|
|
Returns the propagation speed of the wave, |
|
|
in meters per second. |
|
|
It is dependent on the propagation medium. |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy import symbols |
|
|
>>> from sympy.physics.optics import TWave |
|
|
>>> A, phi, f = symbols('A, phi, f') |
|
|
>>> w = TWave(A, f, phi) |
|
|
>>> w.speed |
|
|
299792458*meter/(second*n) |
|
|
""" |
|
|
return self.wavelength*self.frequency |
|
|
|
|
|
@property |
|
|
def angular_velocity(self): |
|
|
""" |
|
|
Returns the angular velocity of the wave, |
|
|
in radians per second. |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy import symbols |
|
|
>>> from sympy.physics.optics import TWave |
|
|
>>> A, phi, f = symbols('A, phi, f') |
|
|
>>> w = TWave(A, f, phi) |
|
|
>>> w.angular_velocity |
|
|
2*pi*f |
|
|
""" |
|
|
return 2*pi*self.frequency |
|
|
|
|
|
@property |
|
|
def wavenumber(self): |
|
|
""" |
|
|
Returns the wavenumber of the wave, |
|
|
in radians per meter. |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy import symbols |
|
|
>>> from sympy.physics.optics import TWave |
|
|
>>> A, phi, f = symbols('A, phi, f') |
|
|
>>> w = TWave(A, f, phi) |
|
|
>>> w.wavenumber |
|
|
pi*second*f*n/(149896229*meter) |
|
|
""" |
|
|
return 2*pi/self.wavelength |
|
|
|
|
|
def __str__(self): |
|
|
"""String representation of a TWave.""" |
|
|
from sympy.printing import sstr |
|
|
return type(self).__name__ + sstr(self.args) |
|
|
|
|
|
__repr__ = __str__ |
|
|
|
|
|
def __add__(self, other): |
|
|
""" |
|
|
Addition of two waves will result in their superposition. |
|
|
The type of interference will depend on their phase angles. |
|
|
""" |
|
|
if isinstance(other, TWave): |
|
|
if self.frequency == other.frequency and self.wavelength == other.wavelength: |
|
|
return TWave(sqrt(self.amplitude**2 + other.amplitude**2 + 2 * |
|
|
self.amplitude*other.amplitude*cos( |
|
|
self.phase - other.phase)), |
|
|
self.frequency, |
|
|
atan2(self.amplitude*sin(self.phase) |
|
|
+ other.amplitude*sin(other.phase), |
|
|
self.amplitude*cos(self.phase) |
|
|
+ other.amplitude*cos(other.phase)) |
|
|
) |
|
|
else: |
|
|
raise NotImplementedError("Interference of waves with different frequencies" |
|
|
" has not been implemented.") |
|
|
else: |
|
|
raise TypeError(type(other).__name__ + " and TWave objects cannot be added.") |
|
|
|
|
|
def __mul__(self, other): |
|
|
""" |
|
|
Multiplying a wave by a scalar rescales the amplitude of the wave. |
|
|
""" |
|
|
other = sympify(other) |
|
|
if isinstance(other, Number): |
|
|
return TWave(self.amplitude*other, *self.args[1:]) |
|
|
else: |
|
|
raise TypeError(type(other).__name__ + " and TWave objects cannot be multiplied.") |
|
|
|
|
|
def __sub__(self, other): |
|
|
return self.__add__(-1*other) |
|
|
|
|
|
def __neg__(self): |
|
|
return self.__mul__(-1) |
|
|
|
|
|
def __radd__(self, other): |
|
|
return self.__add__(other) |
|
|
|
|
|
def __rmul__(self, other): |
|
|
return self.__mul__(other) |
|
|
|
|
|
def __rsub__(self, other): |
|
|
return (-self).__radd__(other) |
|
|
|
|
|
def _eval_rewrite_as_sin(self, *args, **kwargs): |
|
|
return self.amplitude*sin(self.wavenumber*Symbol('x') |
|
|
- self.angular_velocity*Symbol('t') + self.phase + pi/2, evaluate=False) |
|
|
|
|
|
def _eval_rewrite_as_cos(self, *args, **kwargs): |
|
|
return self.amplitude*cos(self.wavenumber*Symbol('x') |
|
|
- self.angular_velocity*Symbol('t') + self.phase) |
|
|
|
|
|
def _eval_rewrite_as_pde(self, *args, **kwargs): |
|
|
mu, epsilon, x, t = symbols('mu, epsilon, x, t') |
|
|
E = Function('E') |
|
|
return Derivative(E(x, t), x, 2) + mu*epsilon*Derivative(E(x, t), t, 2) |
|
|
|
|
|
def _eval_rewrite_as_exp(self, *args, **kwargs): |
|
|
return self.amplitude*exp(I*(self.wavenumber*Symbol('x') |
|
|
- self.angular_velocity*Symbol('t') + self.phase)) |
|
|
|
