Ejemplo n.º 1
0
    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())
Ejemplo n.º 2
0
    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())
Ejemplo n.º 3
0
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)
Ejemplo n.º 4
0
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)
Ejemplo n.º 5
0
    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)
Ejemplo n.º 6
0
    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)
Ejemplo n.º 7
0
    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())
Ejemplo n.º 8
0
    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))
Ejemplo n.º 9
0
    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)))