def __init__(self, settings, thread_count=1): import expresso.pycas as pc super(Fresnel2D, self).__init__(settings) self._thread_count = thread_count self._set_initial_field(settings) pe = settings.partial_differential_equation x, y, z = settings.partial_differential_equation.coordinates R, = self._get_evaluators([pc.exp(pe.F * z.step)], settings, return_type=pc.Types.Complex) D = pc.numpyfy( self._evaluate(pc.exp(-pe.A * z.step * (pc.Symbol('kx')**2)), settings)) if self._F_is_constant_in_z: self.__R_step = R(*self._get_indices()) else: self.__R = R import numpy as np fx = 2 * np.pi / (self._nx * self._get_as(x.step, float, settings)) kx = fx * (self._nx / 2. - np.abs(np.arange(self._nx) - self._nx / 2.)) self.__D_step = D(kx=kx, **self._get_indices_dict())
def __init__(self,settings,thread_count = None): super(FresnelPropagator2D,self).__init__(settings) if thread_count == None: import multiprocessing thread_count = multiprocessing.cpu_count() self._thread_count = thread_count self._set_initial_field(settings) pe = settings.partial_differential_equation x,y,z = settings.partial_differential_equation.coordinates import expresso.pycas as pc R, = self._get_evaluators([pc.exp(pe.F*z.step)],settings,return_type=pc.Types.Complex,parallel=not self._F_is_constant_in_z) if self._F_is_constant_in_z: self.__R_step = R(*self._get_coordinates()) else: self.__R = R D = pc.numpyfy( self._evaluate( pc.exp(-z.step*(pe.A * pc.Symbol('kx')**2 + pe.C * pc.Symbol('ky')**2)) ,settings) ) import numpy as np fx = 2*np.pi/(self._nx*self._get_as(x.step,float,settings)) fy = 2*np.pi/(self._ny*self._get_as(y.step,float,settings)) ky,kx = np.meshgrid( fy*( self._ny/2.-np.abs(np.arange(self._ny)-self._ny/2.) ), fx*( self._nx/2.-np.abs(np.arange(self._nx)-self._nx/2.) ) ) self.__D_step = D(kx=kx,ky=ky,**self._get_coordinate_dict())
def set_1D_boundary_condition(settings): from expresso.pycas import exp s = settings.simulation_box pe = settings.partial_differential_equation pe.u_boundary = pe.u0.subs(s.z, s.zmin) * exp(pe.F.subs(s.z, s.zmin) * s.z)
def set_1D_boundary_condition(settings): from expresso.pycas import exp s = settings.simulation_box pe = settings.partial_differential_equation pe.u_boundary = pe.u0.subs(s.z,s.zmin) * exp(pe.F.subs(s.z,s.zmin)*s.z)
def __init__(self, settings, thread_count=None): super(Fresnel3D, self).__init__(settings) if thread_count == None: import multiprocessing thread_count = multiprocessing.cpu_count() self._thread_count = thread_count pe = settings.partial_differential_equation x, y, z = settings.partial_differential_equation.coordinates import expresso.pycas as pc R, = self._get_evaluators([pc.exp(pe.F * z.step)], settings, return_type=pc.Types.Complex, parallel=not self._F_is_constant_in_z) if self._F_is_constant_in_z: self.__R_step = R(*self._get_indices()) else: self.__R = R D = pc.numpyfy( self._evaluate( pc.exp( -z.step * (pe.A * pc.Symbol('kx')**2 + pe.C * pc.Symbol('ky')**2)), settings)) import numpy as np fx = 2 * np.pi / (self._nx * self._get_as(x.step, float, settings)) fy = 2 * np.pi / (self._ny * self._get_as(y.step, float, settings)) ky, kx = np.meshgrid( fy * (self._ny / 2. - np.abs(np.arange(self._ny) - self._ny / 2.)), fx * (self._nx / 2. - np.abs(np.arange(self._nx) - self._nx / 2.))) self.__C_is_zero = settings.get_numeric(pe.C) == pc.S(0) self.__D_step = D(kx=kx, ky=ky, **self._get_indices_dict()) self._set_initial_field(settings)
def __init__(self, settings, thread_count=1): import expresso.pycas as pc import numpy as np pe = settings.partial_differential_equation x, y, z = settings.partial_differential_equation.coordinates xi = getattr(settings.simulation_box, x.name + 'i') self.__ximin = float(settings.get_unitless(xi.subs(x.symbol, 0))) self.__ximax = float(settings.get_unitless(xi.subs(x.symbol, x.max))) self.__sx = self.__ximax - self.__ximin super(FresnelCS, self).__init__(settings) self._thread_count = thread_count self._set_initial_field(settings) R, = self._get_evaluators([pc.exp(pe.F * z.step)], settings, return_type=pc.Types.Complex) D = pc.numpyfy( self._evaluate(pc.exp(-pe.A * z.step * (pc.Symbol('kx')**2)), settings)) if self._F_is_constant_in_z: self.__R_step = R(*self._get_indices()) else: self.__R = R kx = hankel_freq(self._nx) * ((self._nx - 1) * 1. / self.__sx) self.__D_step = D(kx=kx, **self._get_indices_dict()) self.__hankel_resample_matrix = hankel_resample_matrix( self._nx, (np.arange(self._nx) - self.__ximin) * (self._nx * 1. / self.__sx), cache_key=(self._nx, self.__ximin, self.__sx), xmax=self._nx)
def __init__(self,settings,thread_count=1): import expresso.pycas as pc super(FresnelPropagator1D,self).__init__(settings) self._thread_count = thread_count self._set_initial_field(settings) pe = settings.partial_differential_equation x,y,z = settings.partial_differential_equation.coordinates R, = self._get_evaluators([pc.exp(pe.F*z.step)],settings,return_type=pc.Types.Complex) D = pc.numpyfy( self._evaluate( pc.exp(-pe.A*z.step*(pc.Symbol('kx')**2)) , settings) ) if self._F_is_constant_in_z: self.__R_step = R(*self._get_coordinates()) else: self.__R = R import numpy as np fx = 2*np.pi/(self._nx*self._get_as(x.step,float,settings)) kx = fx*( self._nx/2.-np.abs(np.arange(self._nx)- self._nx/2.) ) self.__D_step = D(kx=kx,**self._get_coordinate_dict())
e = m[s.y] exponents = [(arg.args[0]**arg.args[1])**e for arg in f.args if arg.function == pc.exponentiation] exponents += [arg ** e for arg in f.args if isinstance(arg.value, pc.Number) or arg == pc.I] if len(candidates) != len(f.args): exponents += [pc.multiplication(*[arg for arg in f.args if arg not in candidates])**e] m[s.z] = pc.multiplication(*exponents) canonical_form.add_rule(pc.multiplication(s.x),s.x) canonical_form.add_rule(pc.addition(s.x),s.x) canonical_form.add_rule(pc.exponentiation(s.x),s.x) canonical_form.add_rule(1/s.x, s.x**-1) canonical_form.add_rule(pc.exp(s.x), pc.e**s.x) canonical_form.add_rule(s.x**s.y, s.z, normalize_exponentiation,condition=pc.equal(pc.DominantType(pc.Type(s.y),pc.Types.Real),pc.Types.Real)) canonical_form.add_rule(pc.exp(s.x),pc.e**s.x) canonical_form.add_rule(pc.sqrt(s.x),s.x**(1/pc.S(2))) canonical_form.add_rule(s.x>s.y,s.y<s.x) canonical_form.add_rule(s.x>=s.y,s.y<=s.x) canonical_form.add_rule(s.x<=s.y,pc.Or(s.x<s.y,pc.equal(s.x,s.y))) canonical_form.add_rule(pc.unequal(s.x,s.y),pc.Not(pc.equal(s.x,s.y))); canonical_form.add_rule(abs(s.x),pc.Max(s.x,-s.x),condition=pc.equal(pc.DominantType(pc.Type(s.x),pc.Types.Real),pc.Types.Real)) canonical_form.add_rule(pc.Max(s.a,s.b),-pc.Min(-s.a,-s.b))
if len(candidates) != len(f.args): exponents += [ pc.multiplication( *[arg for arg in f.args if arg not in candidates])**e ] m[s.z] = pc.multiplication(*exponents) canonical_form.add_rule(pc.multiplication(s.x), s.x) canonical_form.add_rule(pc.addition(s.x), s.x) canonical_form.add_rule(pc.exponentiation(s.x), s.x) canonical_form.add_rule(1 / s.x, s.x**-1) canonical_form.add_rule(pc.exp(s.x), pc.e**s.x) canonical_form.add_rule(s.x**s.y, s.z, normalize_exponentiation, condition=pc.equal( pc.DominantType(pc.Type(s.y), pc.Types.Real), pc.Types.Real)) canonical_form.add_rule(pc.exp(s.x), pc.e**s.x) canonical_form.add_rule(pc.sqrt(s.x), s.x**(1 / pc.S(2))) canonical_form.add_rule(s.x > s.y, s.y < s.x) canonical_form.add_rule(s.x >= s.y, s.y <= s.x) canonical_form.add_rule(s.x <= s.y, pc.Or(s.x < s.y, pc.equal(s.x, s.y))) canonical_form.add_rule(pc.unequal(s.x, s.y), pc.Not(pc.equal(s.x, s.y)))