Ejemplo n.º 1
0
    def setUp(self):

        #linear SAMPLE objects
        ct = 4

        lim_t = 31

        lbpar_t = cd.LbFixParams([ct], [lim_t])

        shf_t = 5.0

        band_t = 40.0

        dt = band_t / ct

        diff = [dt]
        shf = [shf_t]
        band = [band_t]

        ptpar = cd.PtFixParams(diff, shf, band)

        lb_t = cd.LbGen(lbpar_t)

        pt_t = cd.PtGen(ptpar)

        dim_lb = (0, 0)

        obj_lb = [lb_t]
        dims_lb = [dim_lb]

        mst_lb = mst.MdimStruct(obj_lb, dims_lb)

        dims_pt = [(0, 0)]
        obj_pt = [pt_t]

        mst_pt = mst.MdimStruct(obj_pt, dims_pt)

        genS = gn.Generator(mst_lb, mst_pt)

        self.gdS = gd.Grid(genS)

        #BOUNDS
        diff = [dt]
        shf = [shf_t - 5.0]
        band = [band_t]

        ptpar = cd.PtFixParams(diff, shf, band)

        pt_t = cd.PtGen(ptpar)

        dims_pt = [(0, 0)]
        obj_pt = [pt_t]

        mst_pt = mst.MdimStruct(obj_pt, dims_pt)

        genB = gn.Generator(mst_lb, mst_pt)

        self.gdB = gd.Grid(genB)

        return
Ejemplo n.º 2
0
 def adapt_scale(self, band_old, n_old, band_new, n_new, did):
     
     dims = (did, did)
     
     X = band_new[1] - band_new[0]
     dx = X / n_new
     shf = band_new[0]
     
     par_lb = cd.LbFixParams( [n_new], [n_new * 4 - 1] )
     par_pt = cd.PtFixParams( [dx], [shf], [X] )
     
     lb_obj = cd.LbGen(par_lb)        
     pt_obj = cd.PtGen(par_pt)
     
     mst_lb = mst.MdimStruct( [lb_obj], [(0,0)] ) 
     mst_pt = mst.MdimStruct( [pt_obj], [(0,0)] )
     
     gen = gn.Generator(mst_lb, mst_pt)      
     rgrid = gd.Grid(gen)
     
     self.samps.replace(rgrid, dims)
     self.bounds.replace(rgrid, dims)
     
     return
Ejemplo n.º 3
0
def factory(bandlims, ns, shf = [0.0], gdtype = 'cartes'):
    
    res = None
    
    if 'cartes' == gdtype: 

        ct = ns[0]

        lim_t = ct * 4 - 1
        
        lbpar_t = cd.LbFixParams( [ct], [lim_t] )

        shf_t = shf[0]
        
        T = bandlims[0][1]
        
        dt = T / ct
        
        diff = [dt]
        shf = [shf_t]
        band = [T]
        
        ptpar = cd.PtFixParams(diff, shf, band)
        
        lb_t = cd.LbGen(lbpar_t)
        
        pt_t = cd.PtGen(ptpar)
        
        dim_lb = (0, 0)
        
        obj_lb = [lb_t]
        dims_lb = [dim_lb]
        
        mst_lb = mst.MdimStruct(obj_lb, dims_lb) 
        
        dims_pt = [ (0, 0) ]
        obj_pt = [pt_t]
        
        mst_pt = mst.MdimStruct(obj_pt, dims_pt)
        
        gen = gn.Generator(mst_lb, mst_pt)
        
        samps = gd.Grid(gen)
        
        shf = [0.0]
        
        ptpar = cd.PtFixParams(diff, shf, band)

        pt_t = cd.PtGen(ptpar)
        
        dims_pt = [ (0, 0) ]
        obj_pt = [pt_t]
        
        mst_pt = mst.MdimStruct(obj_pt, dims_pt)
        
        gen = gn.Generator(mst_lb, mst_pt)
        
        bounds = gd.Grid(gen)
                    
        bandstr = mst.MdimStruct( [ [0, T] ], [ (0,0) ] )
        
        res = Domain(samps, bounds, None, None, True, bandstr)
        
    elif 'polar' == gdtype:
        
        R = bandlims[0][1]
        A = bandlims[1][1]
        
        cr = int( ns[0] )
        ca = int( ns[1] )
        
        lim_r = cr * 4 - 1
        lim_a = ca * 2 - 1
        
        lbpar_r = pl.LbFixParams( [cr], [lim_r] )
        lbpar_a = pl.LbFixParams( [ca], [lim_a] )
        
        shf_r = shf[0]
        shf_a = shf[1]
        
        dr = R / cr
        da = A / ca
        
        diff = [dr, da]
        shf = [shf_r, shf_a]
        band = [R, A]
        
        ptpar = pl.PtFixParams(diff, shf, band)
        
        pol_lb_r = pl.PolarLbGen(lbpar_r)
        pol_lb_a = pl.PolarLbGen(lbpar_a)
        
        pol_pt = pl.PolarPtGen(ptpar)
        
        dim_lb_r = (0, 0)
        dim_lb_a = (1, 1)
        
        obj_lb = [pol_lb_r, pol_lb_a]
        dims_lb = [dim_lb_r, dim_lb_a]
        
        mst_lb = mst.MdimStruct(obj_lb, dims_lb) 
        
        dims_pt = [ (0, 1) ]
        obj_pt = [pol_pt]
        
        mst_pt = mst.MdimStruct(obj_pt, dims_pt)
        
        gen = gn.Generator(mst_lb, mst_pt)
        
        samps = gd.Grid(gen)
        
        shf_r = 0.0
        shf_a = 0.0
        
        ptpar = pl.PtFixParams(diff, shf, band)
        
        pol_pt = pl.PolarPtGen(ptpar)
        
        dims_pt = [ (0, 1) ]
        obj_pt = [pol_pt]
        
        mst_pt = mst.MdimStruct(obj_pt, dims_pt)
        
        gen = gn.Generator(mst_lb, mst_pt)
        
        bounds = gd.Grid(gen)

        volume = vol.Volume( mst.MdimStruct( [vol.sector], [ (0,1) ] ) )
        
        meas = ms.Measure( mst.MdimStruct( [ms.sector], [ (0,1) ] ) )
        
        bandstr = mst.MdimStruct( [ [0, R], [0, A] ], [ (0,0), (1,1) ] )
        
        res = Domain(samps, bounds, volume, meas, True, bandstr)
        
    else:
       
        pass 
    
    return res
Ejemplo n.º 4
0
    def setUp(self):
        
        #linear SAMPLE objects        
        ct = 4

        lim_t = 31
        
        lbpar_t = cd.LbFixParams( [ct], [lim_t] )

        shf_t = 0.0
        
        band_t = 1.0
        
        dt = band_t / ct
        
        diff = [dt]
        shf = [shf_t]
        band = [band_t]
        
        ptpar = cd.PtFixParams(diff, shf, band)
        
        lb_t = cd.LbGen(lbpar_t)
        
        pt_t = cd.PtGen(ptpar)
        
        dim_lb = (0, 0)
        
        obj_lb = [lb_t]
        dims_lb = [dim_lb]
        
        mst_lb = mst.MdimStruct(obj_lb, dims_lb) 
        
        dims_pt = [ (0, 0) ]
        obj_pt = [pt_t]
        
        mst_pt = mst.MdimStruct(obj_pt, dims_pt)
        
        genS = gn.Generator(mst_lb, mst_pt)
        
        gdS = gd.Grid(genS)
        
        #BOUNDS
        diff = [dt]
        shf = [shf_t]
        band = [band_t]
        
        ptpar = cd.PtFixParams(diff, shf, band)
        
        pt_t = cd.PtGen(ptpar)
        
        dims_pt = [ (0, 0) ]
        obj_pt = [pt_t]
        
        mst_pt = mst.MdimStruct(obj_pt, dims_pt)
        
        genB = gn.Generator(mst_lb, mst_pt) 
        
        gdB = gd.Grid(genB)
                
        bandstr = mst.MdimStruct( [ [0.0, 1.0] ], [ (0,0) ] )
        
        symb_t = mst.MdimStruct( ['t'], [ (0,0) ] )
        
        dm_t = dm.Domain(gdS, gdB, None, None, True, bandstr)
        
        self.table = tb.Table(dm_t, symb_t, None, None, None, None, True)
        
        return
Ejemplo n.º 5
0
    def setUp(self):

        cr = 8
        ca = 8

        lim_r = 31
        lim_a = 7

        lbpar_r = pl.LbFixParams([cr], [lim_r])
        lbpar_a = pl.LbFixParams([ca], [lim_a])

        shf_r = 0.0
        shf_a = 0.0

        band_r = 8.0
        band_a = 2.0 * np.pi

        dr = band_r / cr
        da = band_a / ca

        diff = [dr, da]
        shf = [shf_r, shf_a]
        band = [band_r, band_a]

        ptpar = pl.PtFixParams(diff, shf, band)

        pol_lb_r = pl.PolarLbGen(lbpar_r)
        pol_lb_a = pl.PolarLbGen(lbpar_a)

        pol_pt = pl.PolarPtGen(ptpar)

        dim_lb_r = (0, 0)
        dim_lb_a = (1, 1)

        obj_lb = [pol_lb_r, pol_lb_a]
        dims_lb = [dim_lb_r, dim_lb_a]

        mst_lb = mst.MdimStruct(obj_lb, dims_lb)

        dims_pt = [(0, 1)]
        obj_pt = [pol_pt]

        mst_pt = mst.MdimStruct(obj_pt, dims_pt)

        gen = gn.Generator(mst_lb, mst_pt)

        self.gdPol = gd.Grid(gen)

        #linear objects
        ct = 4

        lim_t = 31

        lbpar_t = cd.LbFixParams([ct], [lim_t])

        shf_t = 0.0

        band_t = 4.0

        dt = band_t / ct

        diff = [dt]
        shf = [shf_t]
        band = [band_t]

        ptpar = cd.PtFixParams(diff, shf, band)

        lb_t = cd.LbGen(lbpar_t)

        pt_t = cd.PtGen(ptpar)

        dim_lb = (0, 0)

        obj_lb = [lb_t]
        dims_lb = [dim_lb]

        mst_lb = mst.MdimStruct(obj_lb, dims_lb)

        dims_pt = [(0, 0)]
        obj_pt = [pt_t]

        mst_pt = mst.MdimStruct(obj_pt, dims_pt)

        gen = gn.Generator(mst_lb, mst_pt)

        self.gdA = gd.Grid(gen)

        self.gdB = gd.Grid(gen)

        return
Ejemplo n.º 6
0
    def setUp(self):

        samp_shf = 0.00
        
        #linear SAMPLE objects        
        ct = 4

        lim_t = 31
        
        lbpar_t = cd.LbFixParams( [ct], [lim_t] )

        shf_t = samp_shf
        
        band_t = 1.0
        
        dt = band_t / ct
        
        diff = [dt]
        shf = [shf_t]
        band = [band_t]
        
        ptpar = cd.PtFixParams(diff, shf, band)
        
        lb_t = cd.LbGen(lbpar_t)
        
        pt_t = cd.PtGen(ptpar)
        
        dim_lb = (0, 0)
        
        obj_lb = [lb_t]
        dims_lb = [dim_lb]
        
        mst_lb = mst.MdimStruct(obj_lb, dims_lb) 
        
        dims_pt = [ (0, 0) ]
        obj_pt = [pt_t]
        
        mst_pt = mst.MdimStruct(obj_pt, dims_pt)
        
        genS = gn.Generator(mst_lb, mst_pt)
        
        self.gdS = gd.Grid(genS)
        
        #BOUNDS
        diff = [dt]
        shf = [shf_t - samp_shf]
        band = [band_t]
        
        ptpar = cd.PtFixParams(diff, shf, band)
        
        pt_t = cd.PtGen(ptpar)
        
        dims_pt = [ (0, 0) ]
        obj_pt = [pt_t]
        
        mst_pt = mst.MdimStruct(obj_pt, dims_pt)
        
        genB = gn.Generator(mst_lb, mst_pt) 
        
        self.gdB = gd.Grid(genB)
        
        bandstr = mst.MdimStruct([ [0.0, 1.0] ], [(0,0)])
        
        dmA = dm.Domain(self.gdS, self.gdB, None, None, True, bandstr)
        
        self.dmP2d = dmA.prod(dmA)
        
        self.dmP3d = self.dmP2d.prod(dmA)       
        
        #set up codomains
        T = dmA.bandlims.get_obj((0,0))[1]
        n = dmA.ns.get_obj((0,0)) 
        dt = T/n
        shf = 2
        phi = 1.0 + 0.0j
        ampl = 1.0
        symb = 't'
    
        fcstr = sgl.cyc_stepfc(dt, T, shf, phi, ampl, symb)
        dims = (0,0)
    
        codmstr = mst.MdimStruct( [fcstr], [dims] )
        
        codmA = codm.Codomain(codmstr)
        
        shf = 1
        
        fcstr = sgl.cyc_stepfc(dt, T, shf, phi, ampl, symb)
        dims = (0,0)
        
        codmstr = mst.MdimStruct( [fcstr], [dims] )
        
        codmB = codm.Codomain(codmstr)
        
        self.codmP2d = codmA.prod(codmB)
        
        return