def __init__(self, Wavelength, Name='Wavelength'):
self.Name = Name
self.Value = ToList(Wavelength).astype(float)
self.Format = ".1e"
self.Unit = "[m]"
self.Label = 'Wavelength [m]'
self.Legend = f'Wavelength {self.Unit}'
def __init__(self, PhiOffset, Name='Phi'):
self.Name = Name
self.Value = ToList(PhiOffset).astype(float)
self.Format = "03.1f"
self.Unit = "[Deg]"
self.Label = 'Phi offset'
self.Legend = f'Phi offset {self.Unit}'
def __init__(self, Filter, Name='Filter'):
self.Name = Name
self.Value = ToList(Filter).astype(float)
self.Format = "03.1f"
self.Unit = "[Deg]"
self.Label = 'Polarization filter'
self.Legend = f'Polarization filter {self.Unit}'
def __init__(self, NA, Name='NA'):
self.Name = Name
self.Value = ToList(NA).astype(float)
self.Format = ".1e"
self.Unit = "[1]"
self.Label = 'Numerical aperture'
self.Legend = f'Numerical aperture {self.Unit}'
def __init__(self, Sampling, Name='Sampling'):
self.Name = Name
self.Value = ToList(Sampling).astype(float)
self.Format = ".1e"
self.Unit = "[1]"
self.Label = 'Detector sampling'
self.Legend = f'Detector sampling {self.Unit}'
def __init__(self, Amplitude, Name='Amplitude'):
self.Name = Name
self.Value = ToList(Amplitude).astype(float)
self.Format = ".1f"
self.Unit = "[w.m⁻¹]"
self.Label = 'E_0[w.m⁻¹]'
self.Legend = f'Electric field amplitude {self.Unit}'
def __init__(self, GammaOffset, Name='Gamma'):
self.Name = Name
self.Value = ToList(GammaOffset).astype(float)
self.Format = "03.1f"
self.Unit = "[Deg]"
self.Label = 'Gamma offset'
self.Legend = f'Gamma offset {self.Unit}'
def __init__(self, Diameter, Name='Diameter', Prefix=None):
self.Name = Name
self.Value = ToList(Diameter).astype(float)
self.Format = ".2f"
self.Unit = "[m]"
self.Label = 'Diameter'
self.Legend = f'Diameter {self.Unit}'
if Prefix:
self.Legend = Prefix + ' ' + self.Legend
def __init__(self, Index, Name='Index'):
self.Name = Name
self.Format = ".2f"
self.Unit = "[1]"
self.Label = 'RI'
self.Legend = f'Refractive index {self.Unit}'
if Name == 'nMedium':
self.Value = ToList(Index).astype(float)
else:
self.Value = ToList(Index).astype(complex)
def __init__(self, Material, Name='Material'):
self.Name = Name
self.Format = ""
self.Unit = ""
self.Label = 'Material'
self.Legend = f'Material {self.Unit}'
if Material is None:
self.IsEmpty = True
else:
self.IsEmpty = False
self.Value = ToList(Material)
def Get(self, Input):
"""Methode generate array of the givens parameters as a function of
all independent variables.
Returns
-------
:class:`PyMieSimArray`
Dataframe containing Efficiencies vs. Wavelength, Diameter vs. Index...
"""
Input = ToList(Input)
X = self.SetSource([])
X = self.SetScatterer(X)
if self.DetectorSet:
X = self.SetDetector(X)
self.Xtable = X
self.Ytable = Input
Array = self._Get(Input)
Array = np.rollaxis(Array, 0, len(Array.shape))
return DataV(Array, Xtable=self.Xtable, Ytable=self.Ytable)
def __init__(self, Source=None, kwargs: dict = {}):
self.kwargs = {k: ToList(v) for k, v in kwargs.items()}
self._Source_ = PlaneWave
self._Source = Namespace(kwargs=None)
def __init__(self, Detector, kwargs: dict = {}):
self.isEmpty = False
self.kwargs = {k: ToList(v) for k, v in kwargs.items()}
self._Detector_ = Detector
self._Detector = Namespace(kwargs=None)
def __init__(self, Scatterer=None, kwargs: dict = {}):
if all(['Material' in kwargs.keys(), 'index' in kwargs.keys()]):
raise KeyError(
"You should either choose a material or the RI, not both.")
self.kwargs = {k: ToList(v) for k, v in kwargs.items()}
self._Scatterer_ = Scatterer
self._Scatterer = Namespace(kwargs=None)
self._Source = None
class _Polarization(Base):
def __init__(self, Polarization, Name='Polarization'):
self.Name = Name
self.Value = ToList(Polarization)
self.Label = 'Polarization'
self.Unit = ''
self.Legend = f'Polarization {self.Unit}'
def flatten(self):
return np.array([x.J for x in self.Value]).flatten()
def str(self, item):
return self.Value[item].__str__()
def __str__(self):
return self.Value.__str__()
class _Wavelength(Base):
def __init__(self, Wavelength, Name='Wavelength'):
self.Name = Name
self.Value = ToList(Wavelength).astype(float)
self.Format = ".1e"
self.Unit = "[m]"
self.Label = 'Wavelength [m]'
self.Legend = f'Wavelength {self.Unit}'
def str(self, item):
return f" | {self.Name} : {self.Value[item]:{self.Format}}"
def __str__(self):
if self.Value.size == 1:
return f" | {self.Name} : {self.Value[0]:{self.Format}} {self.Unit}"
else:
return self.Value.__str__()
class _Sampling(Base):
def __init__(self, Sampling, Name='Sampling'):
self.Name = Name
self.Value = ToList(Sampling).astype(float)
self.Format = ".1e"
self.Unit = "[1]"
self.Label = 'Detector sampling'
self.Legend = f'Detector sampling {self.Unit}'
def str(self, item):
return f" | {self.Name} : {self.Value[item]:{self.Format}}"
def __str__(self):
if self.Value.size == 1:
return f" | {self.Name} : {self.Value[0]:{self.Format}} {self.Unit}"
else:
return self.Value.__str__()
def __init__(self, Wavelength: list, Polarization: list, Amplitude: list):
self.Name = 'PlaneWave'
self.kwargs = {
'Wavelength':
_Wavelength(Wavelength, 'Wavelength'),
'Jones':
_Polarization(
[LinearPolarization(x) for x in ToList(Polarization)]),
'Amplitude':
_Amplitude(Amplitude, 'Amplitude')
}
self.kwargs_ = {k: v.flatten() for k, v in self.kwargs.items()}
self.Parameters = [v for k, v in self.kwargs.items() if v is not None]
class _Filter(Base):
def __init__(self, Filter, Name='Filter'):
self.Name = Name
self.Value = ToList(Filter).astype(float)
self.Format = "03.1f"
self.Unit = "[Deg]"
self.Label = 'Polarization filter'
self.Legend = f'Polarization filter {self.Unit}'
def str(self, item):
return f" | {self.Name} : {self.Value[item]:{self.Format}}"
def __str__(self):
if self.Value.size == 1:
return f" | {self.Name} : {self.Value[0]:{self.Format}}"
else:
return self.Value.__str__()
class _NA(Base):
def __init__(self, NA, Name='NA'):
self.Name = Name
self.Value = ToList(NA).astype(float)
self.Format = ".1e"
self.Unit = "[1]"
self.Label = 'Numerical aperture'
self.Legend = f'Numerical aperture {self.Unit}'
def str(self, item):
return f" | {self.Name} : {self.Value[item]:{self.Format}}"
def __str__(self):
if self.Value.size == 1:
return f" | {self.Name} : {self.Value[0]:{self.Format}} {self.Unit}"
else:
return self.Value.__str__()
class _Amplitude(Base):
def __init__(self, Amplitude, Name='Amplitude'):
self.Name = Name
self.Value = ToList(Amplitude).astype(float)
self.Format = ".1f"
self.Unit = "[w.m⁻¹]"
self.Label = 'E_0[w.m⁻¹]'
self.Legend = f'Electric field amplitude {self.Unit}'
def str(self, item):
return f" | {self.Name} : {self.Value[item]:{self.Format}}"
def __str__(self):
if self.Value.size == 1:
return f" | {self.Name} : {self.Value[0]:{self.Format}} {self.Unit}"
else:
return self.Value.__str__()
class _PhiOffset(Base):
def __init__(self, PhiOffset, Name='Phi'):
self.Name = Name
self.Value = ToList(PhiOffset).astype(float)
self.Format = "03.1f"
self.Unit = "[Deg]"
self.Label = 'Phi offset'
self.Legend = f'Phi offset {self.Unit}'
def str(self, item):
return f" | {self.Name} : {self.Value[item]:{self.Format}}"
def __str__(self):
if self.Value.size == 1:
return f" | {self.Name} : {self.Value[0]:{self.Format}} {self.Unit}"
else:
return self.Value.__str__()
class _Diameter(Base):
def __init__(self, Diameter, Name='Diameter', Prefix=None):
self.Name = Name
self.Value = ToList(Diameter).astype(float)
self.Format = ".2f"
self.Unit = "[m]"
self.Label = 'Diameter'
self.Legend = f'Diameter {self.Unit}'
if Prefix:
self.Legend = Prefix + ' ' + self.Legend
def str(self, item):
return f" | {self.Name} : {self.Value[item]:{self.Format}}"
def __str__(self):
if self.Value.size == 1:
return f" | {self.Name} : {self.Value[0]:{self.Format}} {self.Unit}"
else:
return self.Value.__str__()
class _Index(Base):
def __init__(self, Index, Name='Index'):
self.Name = Name
self.Format = ".2f"
self.Unit = "[1]"
self.Label = 'RI'
self.Legend = f'Refractive index {self.Unit}'
if Name == 'nMedium':
self.Value = ToList(Index).astype(float)
else:
self.Value = ToList(Index).astype(complex)
def str(self, item):
return f" | {self.Name} : {self.Value[item]:{self.Format}}"
def __str__(self):
if self.Value.size == 1:
return f" | {self.Name} : {self.Value[0]:{self.Format}} {self.Unit}"
else:
return self.Value.__str__()
def Evaluate(self, wavelength):
self.counter = -1
self.Data
wavelength = ToList(wavelength)
if any(wavelength < self.Boundary[0]) or any(
wavelength > self.Boundary[1]):
raise ValueError(f'Wavelength {wavelength} evaluated \
outside of defined range {self.Boundary}')
nList = np.interp(wavelength, self.Data['wl0'], self.Data['n'])
if 'wl1' not in self.Data:
self.nList = nList
return self.nList
else:
kList = np.interp(wavelength, self.Data['wl1'], self.Data['k'])
self.nList = nList + 1j * kList
return self.nList
class _Material(Base):
def __init__(self, Material, Name='Material'):
self.Name = Name
self.Format = ""
self.Unit = ""
self.Label = 'Material'
self.Legend = f'Material {self.Unit}'
if Material is None:
self.IsEmpty = True
else:
self.IsEmpty = False
self.Value = ToList(Material)
def str(self, item):
return f" | {self.Name} : {self.Value[item]:{self.Format}}"
def __str__(self):
if self.Value.size == 1:
return f" | {self.Name} : {self.Value[0]:{self.Format}} {self.Unit}"
else:
return self.Value.__str__()
def Get(self, Input='Qsca', AsType='pymiesim'):
"""Methode generate array of the givens parameters as a function of
all independent variables.
Returns
-------
:class:`PyMieSimArray`
Dataframe containing Efficiencies vs. Wavelength, Diameter vs. Index...
"""
Input = set(ToList(Input))
self.config['Got'] = [FormatString(element) for element in Input]
self.AssertionType(Input=Input, AsType=AsType)
self.UpdateConfig(Input, AsType)
Array = np.empty(self.config['size'])
if 'Material' in self.ScattererSet.kwargs: self.BindMaterial()
i = 0
for source in self.SourceSet.Generator():
self.ScattererSet._Source = source
for scatterer in self.ScattererSet.Generator():
for detector in self.DetectorSet.Generator():
for prop in Input:
if prop == 'Coupling':
Array[i] = detector.Coupling(scatterer)
i += 1
else:
Array[i] = getattr(scatterer, prop)
i += 1
Array = Array.reshape(self.config['shape'])
return self.ReturnType(Array=Array, AsType=AsType)
def wrapper(*args, **kwargs):
figure = plt.figure(figsize=(10, 5))
ax = figure.add_subplot(111)
ax.grid()
kwargs['y'] = ToList(kwargs['y'])
kwargs['y'] = [FormatString(element) for element in kwargs['y']]
if 'Scale' not in kwargs.keys():
Scale = 'linear'
else:
Scale = kwargs['Scale']
yLog = False
xLog = False
func(*args, **kwargs, figure=figure, ax=ax)
ax.set_ylabel('/'.join(kwargs['y']))
ax.set_xlabel(Arg2Dict[kwargs['x'].lower()]['label'])
if Scale in ['lin', 'linear']:
pass
elif Scale in ['log', 'logarithmic']:
ax.set_yscale('log')
ax.set_xscale('log')
elif Scale in ['xlog', 'xlogarithmic']:
ax.set_xscale('log')
if Scale in ['ylog', 'ylogarithmic']:
ax.set_yscale('log')
ax.legend(loc='upper left', prop={'family': 'monospace', 'size': 7})
return figure
def __init__(self, Polarization, Name='Polarization'):
self.Name = Name
self.Value = ToList(Polarization)
self.Label = 'Polarization'
self.Unit = ''
self.Legend = f'Polarization {self.Unit}'
