def create_linear_system(self, omega):
Calculus.create_linear_system(self, omega)
if self.method == "Recursive Method":
if self.termination == "transmission":
self.Omega, self.back_prop = self.interfaces[-1].Omega()
for i, _l in enumerate(self.layers[::-1]):
self.Omega, Xi = _l.transfert(self.Omega)
self.back_prop = self.back_prop @ Xi
self.Omega, Tau = self.interfaces[-i - 2].transfert(
self.Omega)
self.back_prop = self.back_prop @ Tau
else: # Rigid backing
self.Omega = self.interfaces[-1].Omega()
for i, _l in enumerate(self.layers[::-1]):
self.Omega = _l.transfert(self.Omega)[0]
self.Omega = self.interfaces[-i - 2].transfert(
self.Omega)[0]
elif self.method == "Global Method":
self.A = np.zeros((self.nb_PW - 1, self.nb_PW), dtype=complex)
i_eq = 0
# Loop on the interfaces
for _int in self.interfaces:
if self.method == "Global Method":
i_eq = _int.update_M_global(self.A, i_eq)
self.F = -self.A[:, 0] * np.exp(
1j * self.ky * self.layers[0].d
) # - is for transposition, exponential term is for the phase shift
self.A = np.delete(self.A, 0, axis=1)
def update_frequency(self, omega):
Calculus.update_frequency(self, omega)
self.F_i, self.F_v = [], []
self.A_i, self.A_j, self.A_v = [], [], []
self.T_i, self.T_j, self.T_v = [], [], []
for _ent in self.fem_entities:
_ent.update_frequency(omega)
def __init__(self, **kwargs):
assert "ml" in kwargs
ml = kwargs.get("ml")
Calculus.__init__(self, **kwargs)
MultiLayer.__init__(self, ml)
self.termination = kwargs.get("termination", "rigid")
self.theta_d = kwargs.get("theta_d", 0.0)
self.method = kwargs.get("method", False)
if self.method.lower() in ["recursive", "jap", "recursive method"]:
self.method = "Recursive Method"
else:
self.method = "Global Method"
# Add the adequate interfaces for the PEM. Compute the number of PW for glabal method
self.add_excitation_and_termination(self.method, self.termination)
# Move to the global method if plots are required or if incidence is normal
if self.theta_d == 0 or any(self.plot):
self.method = "Global Method"
# Out files
if self.method == "Global Method":
self.out_file_name = self.file_names + ".GM.txt"
self.info_file_name = self.file_names + ".info.GM.txt"
elif self.method == "Recursive Method":
self.out_file_name = self.file_names + ".RM.txt"
self.info_file_name = self.file_names + ".info.RM.txt"
# Calculus variable (for pylint)
self.kx, self.ky, self.k = None, None, None
self.R, self.T = None, None
def __init__(self, **kwargs):
Calculus.__init__(self, **kwargs)
Mesh.__init__(self, **kwargs)
self.order = kwargs.get("order", 2)
self.interface_zone = kwargs.get("interface_zone", 0.01)
self.interface_ml = kwargs.get("interface_ml", False)
self.F_i, self.F_v = None, None
self.A_i, self.A_j, self.A_v = None, None, None
self.T_i, self.T_j, self.T_v = None, None, None
self.out_file_name = self.name_project + ".FEM.txt"
self.info_file_name = self.name_project + ".info.FEM.txt"
def __init__(self, **kwargs):
Calculus.__init__(self, **kwargs)
Mesh.__init__(self, **kwargs)
self.interface_zone = kwargs.get("interface_zone", 0.01)
self.interface_ml = kwargs.get("interface_ml", False)
self.nb_theta = kwargs.get("nb_theta", 2)
self.theta = (np.pi / 2 + 2 * pi * np.arange(self.nb_theta) /
(self.nb_theta)) * 180 / np.pi
self.F_i, self.F_v = None, None
self.A_i, self.A_j, self.A_v = None, None, None
self.out_file_name = self.name_project + ".DGM.txt"
self.info_file_name = self.name_project + ".info.DGM.txt"
def solve(self):
Calculus.solve(self)
if self.method == "Recursive Method":
self.Omega = self.Omega.reshape(2)
_ = (self.ky / self.k) / (1j * 2 * pi * self.f * Air.Z)
detM = -self.Omega[0] + _ * self.Omega[1]
self.R = (self.Omega[0] + _ * self.Omega[1]) / detM
if self.termination == "transmission":
X_0_minus = 2 * _ / detM
self.Omega = (self.back_prop * X_0_minus).flatten()
self.T = self.Omega[0]
elif self.method == "Global Method":
self.X = LA.solve(self.A, self.F)
self.R = self.X[0]
if self.termination == "transmission":
self.T = self.X[-1]
else:
self.T = None
def update_frequency(self, omega):
Calculus.update_frequency(self, omega)
self.kx = omega * np.sin(self.theta_d * np.pi / 180) / Air.c
self.ky = omega * np.cos(self.theta_d * np.pi / 180) / Air.c
self.k = omega / Air.c
MultiLayer.update_frequency(self, omega, self.kx)
def preprocess(self):
Calculus.preprocess(self)
if self.method == "Global Method":
self.info_file.write("Plane Wave solver // Global method\n")
elif self.method == "Recursive Method":
self.info_file.write("Plane Wave solver // Recursive method\n")
def update_frequency(self, omega):
Calculus.update_frequency(self, omega)
def preprocess(self):
Calculus.preprocess(self)
dgm_preprocess(self)
def resolution(self):
Calculus.resolution(self)
if self.name_server == "il-calc1":
mail = " mailx -s \"DGM pyPLANES Calculation of " + self.name_project + " over on \"" + self.name_server + " [email protected] < " + self.info_file.name
os.system(mail)
def preprocess(self):
Calculus.preprocess(self)
fem_preprocess(self)