flatsky
– Flatsky analysis tools¶
rec_lens
– quadratic lensing reconstruction¶
-
flatsky.rec_lens.
qtt
(nx, ny, D, rL, fC, T1, T2, gtype='')¶ Reconstructing CMB lensing potential and its curl mode from the temperature quadratic estimator
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction fC[lx,ly] (double): Temperature power spectrum on 2D grid, with bounds (nx,ny) T1[lx,ly] (dcmplx): 2D Fourier modes of 1st inverse-variance filtered temperature, with bounds (nx,ny) T2[lx,ly] (dcmplx): 2D Fourier modes of 2nd inverse-variance filtered temperature, with bounds (nx,ny) - Args(optional):
gtype (str): Type of output, i.e., convergence (gtype=’k’) or lensing potential (gtype=’‘, default) - Returns:
glm[lx,ly] (dcmplx): 2D Fourier modes of CMB lensing potential, with bounds (nx,ny) clm[lx,ly] (dcmplx): 2D Fourier modes of Curl mode (pseudo lensing potential), with bounds (nx,ny) - Usage:
glm,clm = flatsky.rec_lens.qtt(nx,ny,D,rL,fC,T1,T2,gtype):
-
flatsky.rec_lens.
qte
(nx, ny, D, rL, fC, T, E, gtype='')¶ Reconstructing CMB lensing potential and its curl mode from the suboptimal TE quadratic estimator
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction fC[lx,ly] (double): TE cross power spectrum on 2D grid, with bounds (nx,ny) T[lx,ly] (dcmplx): 2D Fourier modes of inverse-variance filtered temperature, with bounds (nx,ny) E[lx,ly] (dcmplx): 2D Fourier modes of inverse-variance filtered E-mode, with bounds (nx,ny) - Args(optional):
gtype (str): Type of output, i.e., convergence (gtype=’k’) or lensing potential (gtype=’‘, default) - Returns:
glm[lx,ly] (dcmplx): 2D Fourier modes of CMB lensing potential, with bounds (nx,ny) clm[lx,ly] (dcmplx): 2D Fourier modes of Curl mode (pseudo lensing potential), with bounds (nx,ny) - Usage:
glm,clm = flatsky.rec_lens.qte(nx,ny,D,rL,fC,T,E,gtype):
-
flatsky.rec_lens.
qtb
(nx, ny, D, rL, fC, T, B, gtype='')¶ Reconstructing CMB lensing potential and its curl mode from the TB quadratic estimator
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction fC[lx,ly] (double): TE cross power spectrum on 2D grid, with bounds (nx,ny) T[lx,ly] (dcmplx): 2D Fourier modes of inverse-variance filtered temperature, with bounds (nx,ny) B[lx,ly] (dcmplx): 2D Fourier modes of inverse-variance filtered B-mode, with bounds (nx,ny) - Args(optional):
gtype (str): Type of output, i.e., convergence (gtype=’k’) or lensing potential (gtype=’‘, default) - Returns:
glm[lx,ly] (dcmplx): 2D Fourier modes of CMB lensing potential, with bounds (nx,ny) clm[lx,ly] (dcmplx): 2D Fourier modes of Curl mode (pseudo lensing potential), with bounds (nx,ny) - Usage:
glm,clm = flatsky.rec_lens.qtb(nx,ny,D,rL,fC,T,B,gtype):
-
flatsky.rec_lens.
qee
(nx, ny, D, rL, fC, E1, E2, gtype='')¶ Reconstructing CMB lensing potential and its curl mode from the EE quadratic estimator
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction fC[lx,ly] (double): EE power spectrum on 2D grid, with bounds (nx,ny) E1[lx,ly] (dcmplx): 2D Fourier modes of 1st inverse-variance filtered E-mode, with bounds (nx,ny) E2[lx,ly] (dcmplx): 2D Fourier modes of 2nd inverse-variance filtered E-mode, with bounds (nx,ny) - Args(optional):
gtype (str): Type of output, i.e., convergence (gtype=’k’) or lensing potential (gtype=’‘, default) - Returns:
glm[lx,ly] (dcmplx): 2D Fourier modes of CMB lensing potential, with bounds (nx,ny) clm[lx,ly] (dcmplx): 2D Fourier modes of Curl mode (pseudo lensing potential), with bounds (nx,ny) - Usage:
glm,clm = flatsky.rec_lens.qee(nx,ny,D,rL,fC,E1,E2,gtype):
-
flatsky.rec_lens.
qeb
(nx, ny, D, rL, fC, E, B, gtype='')¶ Reconstructing CMB lensing potential and its curl mode from the EB quadratic estimator
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction fC[lx,ly] (double): EE power spectrum on 2D grid, with bounds (nx,ny) E[lx,ly] (dcmplx): 2D Fourier modes of inverse-variance filtered E-mode, with bounds (nx,ny) B[lx,ly] (dcmplx): 2D Fourier modes of inverse-variance filtered B-mode, with bounds (nx,ny) - Args(optional):
gtype (str): Type of output, i.e., convergence (gtype=’k’) or lensing potential (gtype=’‘, default) - Returns:
glm[lx,ly] (dcmplx): 2D Fourier modes of CMB lensing potential, with bounds (nx,ny) clm[lx,ly] (dcmplx): 2D Fourier modes of Curl mode (pseudo lensing potential), with bounds (nx,ny) - Usage:
glm,clm = flatsky.rec_lens.qeb(nx,ny,D,rL,fC,E,B,gtype):
-
flatsky.rec_lens.
qbb
(nx, ny, D, rL, fC, B1, B2, gtype='')¶ Reconstructing CMB lensing potential and its curl mode from the BB quadratic estimator
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction fC[lx,ly] (double): BB power spectrum on 2D grid, with bounds (nx,ny) B1[lx,ly] (dcmplx): 2D Fourier modes of 1st inverse-variance filtered B-mode, with bounds (nx,ny) B2[lx,ly] (dcmplx): 2D Fourier modes of 2nd inverse-variance filtered B-mode, with bounds (nx,ny) - Args(optional):
gtype (str): Type of output, i.e., convergence (gtype=’k’) or lensing potential (gtype=’‘, default) - Returns:
glm[lx,ly] (dcmplx): 2D Fourier modes of CMB lensing potential, with bounds (nx,ny) clm[lx,ly] (dcmplx): 2D Fourier modes of Curl mode (pseudo lensing potential), with bounds (nx,ny) - Usage:
glm,clm = flatsky.rec_lens.qbb(nx,ny,D,rL,fC,B1,B2,gtype):
rec_rot
– quadratic pol. rot. reconstruction¶
-
flatsky.rec_rot.
qte
(nx, ny, D, rL, fC, T, E)¶ Reconstructing anisotropic pol. rot. angles from TE quadratic estimator
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction fC[lx,ly] (double): TE cross power spectrum on 2D grid, with bounds (nx,ny) T[lx,ly] (dcmplx): 2D Fourier modes of inverse-variance filtered temperature, with bounds (nx,ny) E[lx,ly] (dcmplx): 2D Fourier modes of inverse-variance filtered E-mode, with bounds (nx,ny) - Returns:
alm[lx,ly] (dcmplx): 2D Fourier modes of anisotropic pol. rot. angles, with bounds (nx,ny) - Usage:
alm = flatsky.rec_rot.qte(nx,ny,D,rL,fC,T,E):
-
flatsky.rec_rot.
qtb
(nx, ny, D, rL, fC, T, B)¶ Reconstructing anisotropic pol. rot. angles from TB quadratic estimator
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction fC[lx,ly] (double): TE cross power spectrum on 2D grid, with bounds (nx,ny) T[lx,ly] (dcmplx): 2D Fourier modes of inverse-variance filtered temperature, with bounds (nx,ny) B[lx,ly] (dcmplx): 2D Fourier modes of inverse-variance filtered B-mode, with bounds (nx,ny) - Returns:
alm[lx,ly] (dcmplx): 2D Fourier modes of anisotropic pol. rot. angles, with bounds (nx,ny) - Usage:
alm = flatsky.rec_rot.qtb(nx,ny,D,rL,fC,T,B):
-
flatsky.rec_rot.
qee
(nx, ny, D, rL, fC, E1, E2)¶ Reconstructing anisotropic pol. rot. angles from EE quadratic estimator
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction fC[lx,ly] (double): EE power spectrum on 2D grid, with bounds (nx,ny) E1[lx,ly] (dcmplx): 2D Fourier modes of 1st inverse-variance filtered E-mode, with bounds (nx,ny) E2[lx,ly] (dcmplx): 2D Fourier modes of 2nd inverse-variance filtered E-mode, with bounds (nx,ny) - Returns:
alm[lx,ly] (dcmplx): 2D Fourier modes of anisotropic pol. rot. angles, with bounds (nx,ny) - Usage:
alm = flatsky.rec_rot.qee(nx,ny,D,rL,fC,E1,E2):
-
flatsky.rec_rot.
qeb
(nx, ny, D, rL, EE, E, B, BB=0)¶ Reconstructing anisotropic pol. rot. angles from EB quadratic estimator
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction fC[lx,ly] (double): EE power spectrum on 2D grid, with bounds (nx,ny) E[lx,ly] (dcmplx): 2D Fourier modes of inverse-variance filtered E-mode, with bounds (nx,ny) B[lx,ly] (dcmplx): 2D Fourier modes of inverse-variance filtered B-mode, with bounds (nx,ny) - Args(Optional):
BB[lx,ly] (double): Theory B-mode spectrum on 2D grid, with bounds (nx,ny), default to BB=0 - Returns:
alm[lx,ly] (dcmplx): 2D Fourier modes of anisotropic pol. rot. angles, with bounds (nx,ny) - Usage:
alm = flatsky.rec_rot.qeb(nx,ny,D,rL,EE,E,B,BB):
rec_tau
– quadratic patchy tau reconstruction¶
-
flatsky.rec_tau.
qtt
(nx, ny, D, rL, fC, T1, T2)¶ Reconstructing patchy tau from the temperature quadratic estimator
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction fC[lx,ly] (double): Temperature power spectrum on 2D grid, with bounds (nx,ny) T1[lx,ly] (dcmplx): 2D Fourier modes of 1st inverse-variance filtered temperature, with bounds (nx,ny) T2[lx,ly] (dcmplx): 2D Fourier modes of 2nd inverse-variance filtered temperature, with bounds (nx,ny) - Returns:
tlm[lx,ly] (dcmplx): 2D Fourier modes of patchy tau, with bounds (nx,ny) - Usage:
tlm = flatsky.rec_tau.qtt(nx,ny,D,rL,fC,T1,T2):
-
flatsky.rec_tau.
qte
(nx, ny, D, rL, fC, T, E)¶ Reconstructing patchy tau from the suboptimal TE quadratic estimator
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction fC[lx,ly] (double): TE cross power spectrum on 2D grid, with bounds (nx,ny) T[lx,ly] (dcmplx): 2D Fourier modes of inverse-variance filtered temperature, with bounds (nx,ny) E[lx,ly] (dcmplx): 2D Fourier modes of inverse-variance filtered E-mode, with bounds (nx,ny) - Returns:
tlm[lx,ly] (dcmplx): 2D Fourier modes of patchy tau, with bounds (nx,ny) - Usage:
tlm = flatsky.rec_tau.qte(nx,ny,D,rL,fC,T,E):
-
flatsky.rec_tau.
qtb
(nx, ny, D, rL, fC, T, B)¶ Reconstructing patchy tau from the TB quadratic estimator
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction fC[lx,ly] (double): TE cross power spectrum on 2D grid, with bounds (nx,ny) T[lx,ly] (dcmplx): 2D Fourier modes of inverse-variance filtered temperature, with bounds (nx,ny) B[lx,ly] (dcmplx): 2D Fourier modes of inverse-variance filtered B-mode, with bounds (nx,ny) - Returns:
tlm[lx,ly] (dcmplx): 2D Fourier modes of patchy tau, with bounds (nx,ny) - Usage:
tlm = flatsky.rec_tau.qtb(nx,ny,D,rL,fC,T,B):
-
flatsky.rec_tau.
qee
(nx, ny, D, rL, fC, E1, E2)¶ Reconstructing patchy tau from the EE quadratic estimator
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction fC[lx,ly] (double): EE power spectrum on 2D grid, with bounds (nx,ny) E1[lx,ly] (dcmplx): 2D Fourier modes of 1st inverse-variance filtered E-mode, with bounds (nx,ny) E2[lx,ly] (dcmplx): 2D Fourier modes of 2nd inverse-variance filtered E-mode, with bounds (nx,ny) - Returns:
tlm[lx,ly] (dcmplx): 2D Fourier modes of patchy tau, with bounds (nx,ny) - Usage:
tlm = flatsky.rec_tau.qee(nx,ny,D,rL,fC,E1,E2):
-
flatsky.rec_tau.
qeb
(nx, ny, D, rL, fE, fB, E, B)¶ Reconstructing patchy tau from the EB quadratic estimator
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction fE[lx,ly] (double): EE power spectrum on 2D grid, with bounds (nx,ny) fB[lx,ly] (double): BB power spectrum on 2D grid, with bounds (nx,ny) E[lx,ly] (dcmplx): 2D Fourier modes of inverse-variance filtered E-mode, with bounds (nx,ny) B[lx,ly] (dcmplx): 2D Fourier modes of inverse-variance filtered B-mode, with bounds (nx,ny) - Returns:
tlm[lx,ly] (dcmplx): 2D Fourier modes of patchy tau, with bounds (nx,ny) - Usage:
tlm = flatsky.rec_tau.qeb(nx,ny,D,rL,fE,fB,E,B):
rec_src
– quadratic point-src reconstruction¶
-
flatsky.rec_src.
qtt
(nx, ny, D, rL, T1, T2)¶ Reconstructing point source fields from the temperature quadratic estimator
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction fC[lx,ly] (double): Temperature power spectrum on 2D grid, with bounds (nx,ny) T1[lx,ly] (dcmplx): 2D Fourier modes of 1st inverse-variance filtered temperature, with bounds (nx,ny) T2[lx,ly] (dcmplx): 2D Fourier modes of 2nd inverse-variance filtered temperature, with bounds (nx,ny) - Returns:
slm[lx,ly] (dcmplx): 2D Fourier modes of point source fields, with bounds (nx,ny) - Usage:
slm = flatsky.rec_src.qtt(nx,ny,D,rL,T1,T2):
-
flatsky.rec_src.
qte
(nx, ny, D, rL, T, E)¶ Reconstructing point source fields from the suboptimal TE quadratic estimator
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction fC[lx,ly] (double): TE cross power spectrum on 2D grid, with bounds (nx,ny) T[lx,ly] (dcmplx): 2D Fourier modes of inverse-variance filtered temperature, with bounds (nx,ny) E[lx,ly] (dcmplx): 2D Fourier modes of inverse-variance filtered E-mode, with bounds (nx,ny) - Returns:
slm[lx,ly] (dcmplx): 2D Fourier modes of point source fields, with bounds (nx,ny) - Usage:
slm = flatsky.rec_src.qte(nx,ny,D,rL,T,E):
-
flatsky.rec_src.
qtb
(nx, ny, D, rL, T, B)¶ Reconstructing point source fields from the TB quadratic estimator
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction fC[lx,ly] (double): TE cross power spectrum on 2D grid, with bounds (nx,ny) T[lx,ly] (dcmplx): 2D Fourier modes of inverse-variance filtered temperature, with bounds (nx,ny) B[lx,ly] (dcmplx): 2D Fourier modes of inverse-variance filtered B-mode, with bounds (nx,ny) - Returns:
slm[lx,ly] (dcmplx): 2D Fourier modes of point source fields, with bounds (nx,ny) - Usage:
slm = flatsky.rec_src.qtb(nx,ny,D,rL,T,B):
-
flatsky.rec_src.
qee
(nx, ny, D, rL, E1, E2)¶ Reconstructing point source fields from the EE quadratic estimator
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction fC[lx,ly] (double): EE power spectrum on 2D grid, with bounds (nx,ny) E1[lx,ly] (dcmplx): 2D Fourier modes of 1st inverse-variance filtered E-mode, with bounds (nx,ny) E2[lx,ly] (dcmplx): 2D Fourier modes of 2nd inverse-variance filtered E-mode, with bounds (nx,ny) - Returns:
slm[lx,ly] (dcmplx): 2D Fourier modes of point source fields, with bounds (nx,ny) - Usage:
slm = flatsky.rec_src.qee(nx,ny,D,rL,E1,E2):
-
flatsky.rec_src.
qeb
(nx, ny, D, rL, E, B)¶ Reconstructing point source fields from the EB quadratic estimator
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction fC[lx,ly] (double): EE power spectrum on 2D grid, with bounds (nx,ny) E[lx,ly] (dcmplx): 2D Fourier modes of inverse-variance filtered E-mode, with bounds (nx,ny) B[lx,ly] (dcmplx): 2D Fourier modes of inverse-variance filtered B-mode, with bounds (nx,ny) - Returns:
slm[lx,ly] (dcmplx): 2D Fourier modes of point source fields, with bounds (nx,ny) - Usage:
slm = flatsky.rec_src.qeb(nx,ny,D,rL,E,B):
norm_lens
– normalization of quadratic lensing reconstruction¶
-
flatsky.norm_lens.
qtt
(nx, ny, D, rL, OT, TT, eL)¶ Normalization of the temperature quadratic estimator for CMB lensing potential and its curl mode
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction OT[lx,ly] (double): Inverse of Observed temperature power spectrum on 2D grid, with bounds (nx,ny) TT[lx,ly] (double): Theory temperature power spectrum on 2D grid, with bounds (nx,ny) eL[2] (int): Minimum and maximum multipole of output normalization spectrum, with bounds (2) - Returns:
Ag[lx,ly] (dcmplx): Normalization of CMB lensing potential on 2D grid, with bounds (nx,ny) Ac[lx,ly] (dcmplx): Normalization of Curl mode (pseudo lensing potential) on 2D grid, with bounds (nx,ny) - Usage:
Ag,Ac = flatsky.norm_lens.qtt(nx,ny,D,rL,OT,TT,eL):
-
flatsky.norm_lens.
qte
(nx, ny, D, rL, OT, OE, TE, eL)¶ Normalization of the TE quadratic estimator for CMB lensing potential and its curl mode
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction OT[lx,ly] (double): Inverse of Observed temperature power spectrum on 2D grid, with bounds (nx,ny) OE[lx,ly] (double): Inverse of Observed E-mode power spectrum on 2D grid, with bounds (nx,ny) TE[lx,ly] (double): Theory TE cross spectrum on 2D grid, with bounds (nx,ny) eL[2] (int): Minimum and maximum multipole of output normalization spectrum, with bounds (2) - Returns:
Ag[lx,ly] (dcmplx): Normalization of CMB lensing potential on 2D grid, with bounds (nx,ny) Ac[lx,ly] (dcmplx): Normalization of Curl mode (pseudo lensing potential) on 2D grid, with bounds (nx,ny) - Usage:
Ag,Ac = flatsky.norm_lens.qte(nx,ny,D,rL,OT,OE,TE,eL):
-
flatsky.norm_lens.
qtb
(nx, ny, D, OT, OB, TE, rL, eL)¶ Normalization of the TB quadratic estimator for CMB lensing potential and its curl mode
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction OT[lx,ly] (double): Inverse of Observed temperature power spectrum on 2D grid, with bounds (nx,ny) OB[lx,ly] (double): Inverse of Observed B-mode power spectrum on 2D grid, with bounds (nx,ny) TE[lx,ly] (double): Theory TE cross spectrum on 2D grid, with bounds (nx,ny) eL[2] (int): Minimum and maximum multipole of output normalization spectrum, with bounds (2) - Returns:
Ag[lx,ly] (dcmplx): Normalization of CMB lensing potential on 2D grid, with bounds (nx,ny) Ac[lx,ly] (dcmplx): Normalization of Curl mode (pseudo lensing potential) on 2D grid, with bounds (nx,ny) - Usage:
Ag,Ac = flatsky.norm_lens.qtb(nx,ny,D,OT,OB,TE,rL,eL):
-
flatsky.norm_lens.
qee
(nx, ny, D, OE, EE, rL, eL)¶ Normalization of the EE quadratic estimator for CMB lensing potential and its curl mode
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction OE[lx,ly] (double): Inverse of Observed E-mode power spectrum on 2D grid, with bounds (nx,ny) EE[lx,ly] (double): Theory E-mode spectrum on 2D grid, with bounds (nx,ny) eL[2] (int): Minimum and maximum multipole of output normalization spectrum, with bounds (2) - Returns:
Ag[lx,ly] (dcmplx): Normalization of CMB lensing potential on 2D grid, with bounds (nx,ny) Ac[lx,ly] (dcmplx): Normalization of Curl mode (pseudo lensing potential) on 2D grid, with bounds (nx,ny) - Usage:
Ag,Ac = flatsky.norm_lens.qee(nx,ny,D,OE,EE,rL,eL):
-
flatsky.norm_lens.
qeb
(nx, ny, D, OE, OB, EE, rL, eL)¶ Normalization of the EB quadratic estimator for CMB lensing potential and its curl mode
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction OE[lx,ly] (double): Inverse of Observed E-mode power spectrum on 2D grid, with bounds (nx,ny) OB[lx,ly] (double): Inverse of Observed B-mode power spectrum on 2D grid, with bounds (nx,ny) EE[lx,ly] (double): Theory E-mode spectrum on 2D grid, with bounds (nx,ny) eL[2] (int): Minimum and maximum multipole of output normalization spectrum, with bounds (2) - Returns:
Ag[lx,ly] (dcmplx): Normalization of CMB lensing potential on 2D grid, with bounds (nx,ny) Ac[lx,ly] (dcmplx): Normalization of Curl mode (pseudo lensing potential) on 2D grid, with bounds (nx,ny) - Usage:
Ag,Ac = flatsky.norm_lens.qeb(nx,ny,D,OE,OB,EE,rL,eL):
norm_rot
– normalization of quadratic pol. rot. reconstruction¶
-
flatsky.norm_rot.
qeb
(nx, ny, D, rL, IE, IB, EE, eL, BB=0)¶ Normalization of the EB quadratic estimator for anisotropic pol. rot. angles
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction IE[lx,ly] (double): Inverse of observed E-mode power spectrum on 2D grid, with bounds (nx,ny) IB[lx,ly] (double): Inverse of observed B-mode power spectrum on 2D grid, with bounds (nx,ny) EE[lx,ly] (double): Theory E-mode spectrum on 2D grid, with bounds (nx,ny) eL[2] (int): Minimum and maximum multipole of output normalization spectrum, with bounds (2) - Args(Optional):
BB[lx,ly] (double): Theory B-mode spectrum on 2D grid, with bounds (nx,ny), default to BB=0 - Returns:
Aa[lx,ly] (dcmplx): Normalization of anisotropic pol. rot. angles on 2D grid, with bounds (nx,ny) - Usage:
Aa = flatsky.norm_rot.qeb(nx,ny,D,rL,IE,IB,EE,eL,BB):
norm_tau
– normalization of quadratic patchy tay reconstruction¶
-
flatsky.norm_tau.
qtt
(nx, ny, D, rL, OT, TT, eL)¶ Normalization of the temperature quadratic estimator for patchy tau
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction OT[lx,ly] (double): Inverse of Observed temperature power spectrum on 2D grid, with bounds (nx,ny) TT[lx,ly] (double): Theory temperature power spectrum on 2D grid, with bounds (nx,ny) eL[2] (int): Minimum and maximum multipole of output normalization spectrum, with bounds (2) - Returns:
At[lx,ly] (dcmplx): Normalization of patchy tau on 2D grid, with bounds (nx,ny) - Usage:
At = flatsky.norm_tau.qtt(nx,ny,D,rL,OT,TT,eL):
-
flatsky.norm_tau.
qeb
(nx, ny, D, rL, IE, IB, EE, eL)¶ Normalization of the EB quadratic estimator for patchy tau
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) rL[2] (int): Minimum and maximum multipole of CMB for reconstruction IE[lx,ly] (double): Inverse of observed E-mode power spectrum on 2D grid, with bounds (nx,ny) IB[lx,ly] (double): Inverse of observed B-mode power spectrum on 2D grid, with bounds (nx,ny) EE[lx,ly] (double): Theory E-mode spectrum on 2D grid, with bounds (nx,ny) eL[2] (int): Minimum and maximum multipole of output normalization spectrum, with bounds (2) - Returns:
At[lx,ly] (dcmplx): Normalization of patchy tau on 2D grid, with bounds (nx,ny) - Usage:
At = flatsky.norm_tau.qeb(nx,ny,D,rL,IE,IB,EE,eL):
bispec
– bispectrum tools¶
-
flatsky.bispec.
bispec_norm
(nx, ny, D, bp, bn=1, dbin_max=-1)¶ - Usage:
norm = flatsky.bispec.bispec_norm(nx,ny,D,bp,dbin_max,bn):
-
flatsky.bispec.
bispec_bin
(kmap, bp, bn=1, kn=1, nx=0, ny=0, dbin_max=-1)¶ - Usage:
bispec = flatsky.bispec.bispec_bin(kn,bn,nx,ny,kmap,bp,dbin_max):
-
flatsky.bispec.
binfilter
(nx, ny, D, bp, bn=1)¶ The multipole bin binary-mask given on the 2D Fourier grids so that M = 1 inside the multipole bin and 0 otherwise
- Args:
nx, ny (int): Number of Lx and Ly grids D[2] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) bp[bn+1] (double): Multipole bin edges - Returns:
bf[bn,nx,ny] (double): The multipole bin binary-mask for each multipol bin - Usage:
bf = flatsky.bispec.binfilter(nx,ny,D,bp,bn):
-
flatsky.bispec.
bispec_norm_1d
(nx, ny, D, bfs, bn=1)¶ Normalization of the 1D binned bispectrum estimator
- Args:
nx, ny (int): Number of Lx and Ly grids D[2] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) bfs[3,bn,nx,ny] (double): Multipole bin mask on 2D grids obtained from the binfilter function - Returns:
bnorm[bn] (double): Normalization of 1D binned bispectrum at each multipole bin - Usage:
bnorm = flatsky.bispec.bispec_norm_1d(nx,ny,D,bfs,bn):
-
flatsky.bispec.
bispec_bin_1d
(nx, ny, D, bfs, bnorm, alm, bn=1)¶ 1D binned bispectrum estimator
- Args:
nx, ny (int): Number of Lx and Ly grids D[2] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) bfs[3,bn,nx,ny] (double): Multipole bin mask on 2D grids obtained from the binfilter function bnorm[bn] (double): Normalization of 1D binned bispectrum at each multipole bin alm[3,nx,ny] (dcmplx): Fourier modes for each leg - Returns:
bispec[bn] (double): 1D binned bispectrum at each multipole bin - Usage:
bispec = flatsky.bispec.bispec_bin_1d(nx,ny,D,bfs,bnorm,alm,bn):
utils
– other tools¶
-
flatsky.utils.
map2alm
(nx, ny, D, map)¶ DFT for 2D array.
- Args:
nx, ny (int): Number of x and y grids D[2] (double): Side length (x and y) of map map[x,y] (double): Map on 2D grid with bounds (nx,ny) - Returns:
alm[x,y] (dcmplx): Fourier modes on 2D grid, with bounds (nx,ny) - Usage:
alm = flatsky.utils.map2alm(nx,ny,D,map):
-
flatsky.utils.
alm2map
(nx, ny, D, alm)¶ DFT for 2D array.
- Args:
nx, ny (int): Number of Lx and Ly grids D[2] (double): Side length (x and y) of map alm[x,y] (dcmplx): Fourier modes on 2D grid to be transformed, with bounds (nx,ny) - Returns:
map[x,y] (double): Map on 2D grid, with bounds (nx,ny) - Usage:
map = flatsky.utils.alm2map(nx,ny,D,alm):
-
flatsky.utils.
el2d
(nx, ny, D)¶ Return absolute value of multipole in 2D grids
- Args:
nx, ny (int): number of Lx and Ly grids D[xy] (double): map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) - Returns:
els[nx,ny] (double): absolute value of Fourier mode, (Lx**2+Ly**2)**0.5, with bounds (nx,ny) - Usage:
els = flatsky.utils.el2d(nx,ny,D):
-
flatsky.utils.
elarrays
(nx, ny, D)¶ Return Lx, Ly, absolute value of multipole, and its inverse in 2D grids
- Args:
nx, ny (int): number of Lx and Ly grids D[xy] (double): map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) - Returns:
elx[nx,ny] (double): Lx, with bounds (nx,ny) ely[nx,ny] (double): Ly, with bounds (nx,ny) els[nx,ny] (double): absolute value of Fourier mode, (Lx**2+Ly**2)**0.5, with bounds (nx,ny) eli[nx,ny] (double): inverse of els, with bounds (nx,ny) - Usage:
elx,ely,els,eli = flatsky.utils.elarrays(nx,ny,D):
-
flatsky.utils.
elmask
(nx, ny, D, lmin=0, lmax=1000, lxcut=0, lycut=0)¶ Return mask in 2D Fourier space. The lmask is unity at lmin<=|L|<=lmax, |Lx|>=lxcut, |Ly|>=lycut, and otherwize zero.
- Args:
nx, ny (int): number of Lx and Ly grids D[xy] (double): map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) - Args(optional):
lmin/lmax (int): Minimum/Maximum of multipoles lxcut/lycut (int): Remove |Lx|<lxcut / |Ly|<lycut cut of multipoles - Returns:
lmask[nx,ny] (double): Mask, with bounds (nx,ny) - Usage:
lmask = flatsky.utils.elmask(nx,ny,D,lmin,lmax,lxcut,lycut):
-
flatsky.utils.
alm2bcl
(bn, oL, nx, ny, D, alm1, spc='', alm2=None)¶ Compute angular power spectrum from Fourier modes, with multipole binning
- Args:
bn (int): number of multipole bin oL[2] (int): minimum and maximum multipoles of the output cl nx, ny (int): number of Lx and Ly grids D[xy] (double): map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) alm1[nx,ny] (dcmplx): Fourier mode, with bounds (nx,ny) - Args(optional):
alm2[nx,ny] (dcmplx): Fourier mode, with bounds (nx,ny), default to None spc (str): type of multipole binning, i.e., linear spacing (spc=’‘, default), or log spacing (spc=’log’) - Returns:
Cb[bin] (double): angular power spectrum with multipole binning, with bounds (bn) - Usage:
Cb = flatsky.utils.alm2bcl(bn,oL,nx,ny,D,alm1,alm2,spc):
-
flatsky.utils.
c2d2bcl
(nx, ny, D, c2d, bn, oL, spc='')¶ Return 1D angular power spectrum with multipole binning from a 2D power spectrum
- Args:
nx, ny (int): number of Lx and Ly grids D[xy] (double): map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) c2d[nx,ny] (double): 2D power spectrum, with bounds (nx,ny) bn (int): number of multipole bin oL[2] (int): minimum and maximum multipoles of the output cl - Args(optional):
spc (str): type of multipole binning, i.e., linear spacing (spc=’‘, default), or log spacing (spc=’log’) - Returns:
Cb[bin] (double): angular power spectrum with multipole binning, with bounds (bn) - Usage:
Cb = flatsky.utils.c2d2bcl(nx,ny,D,c2d,bn,oL,spc):
-
flatsky.utils.
cl2c2d
(nx, ny, D, lmin, lmax, Cl, method='linear')¶ Assign values of 1D angular power spectrum on to 2D grid with linear interpolation
- Args:
nx, ny (int): number of Lx and Ly grids D[xy] (double): map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) lmin (int): minimum multipole of cl to be interpolated lmax (int): maximum multipole of cl to be interpolated Cl[l] (double): 1D power spectrum, with bounds (0:lmax) - Args(optional):
method (str): type of interpolation method, i.e., linear interpolation (method=’linear’, default), or step (method=’step’) - Returns:
c2d[nx,ny] (double): 2D power spectrum, with bounds (nx,ny) - Usage:
c2d = flatsky.utils.cl2c2d(nx,ny,D,lmin,lmax,Cl,method):
-
flatsky.utils.
cb2c2d
(bn, bc, nx, ny, D, lmin, lmax, Cb, method='')¶ Assign values of 1D angular power spectrum on to 2D grid with linear interpolation
- Args:
bn (int): number of multipole bins bc[bin] (double): multipole bin center, with bounds (bn) nx, ny (int): number of Lx and Ly grids D[xy] (double): map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) lmin (int): minimum multipole of cl to be interpolated lmax (int): maximum multipole of cl to be interpolated Cb[bin] (double): 1D power spectrum with multipole binning, with bounds (bn) - Args(optional):
method (str): interpolation method from binned to unbinned angular spectrum, i.e., spline (‘’, default), or linear (‘linear’) interpolation - Returns:
c2d[nx,ny] (double): 2D power spectrum, with bounds (nx,ny) - Usage:
C2d = flatsky.utils.cb2c2d(bn,bc,nx,ny,D,lmin,lmax,Cb,method):
-
flatsky.utils.
gauss1alm
(nx, ny, D, lmin, lmax, Cl)¶ Generate random gaussian fields in 2D Fourier space for a given isotropic spectrum, satisfying a^*_l = a_{-l}
- Args:
nx, ny (int): number of Lx and Ly grids D[xy] (double): map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) lmin (int): minimum multipole of cl to be interpolated lmax (int): maximum multipole of cl to be interpolated Cl[l] (double): 1D power spectrum, with bounds (0:lmax) - Returns:
alm[lx,ly] (dcmplx): random gaussian fields on 2D Fourier plane, with bounds (nx,ny) - Usage:
alm = flatsky.utils.gauss1alm(nx,ny,D,lmin,lmax,Cl):
-
flatsky.utils.
gauss2alm
(nx, ny, D, lmin, lmax, TT, TE, EE)¶ Generate two correlated random gaussian fields in 2D Fourier space for a given isotropic spectrum
- Args:
nx, ny (int): number of Lx and Ly grids D[xy] (double): map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) lmin (int): minimum multipole of cl to be interpolated lmax (int): maximum multipole of cl to be interpolated TT[l] (double): the 1st 1D power spectrum, with bounds (0:lmax) TE[l] (double): the cross 1D power spectrum, with bounds (0:lmax) EE[l] (double): the 2nd 1D power spectrum, with bounds (0:lmax) - Returns:
tlm[lx,ly] (dcmplx): the 1st random gaussian fields on 2D Fourier plane, with bounds (nx,ny) elm[lx,ly] (dcmplx): the 2nd random gaussian fields on 2D Fourier plane, with bounds (nx,ny) - Usage:
tlm,elm = flatsky.utils.gauss2alm(nx,ny,D,lmin,lmax,TT,TE,EE):
-
flatsky.utils.
window_sin
(nx, ny, D, ap=1, cut=1)¶ Return a sin window function.
- Args:
nx, ny (int): Number of Lx and Ly grids D[xy] (double): Map side length, or equivalent to dLx/2pi, dLy/2pi, with bounds (2) - Args(Optional):
ap (double): Apodization parameter defined by apodized-range = (1-ap) x (cut)mapsize, from 0 (full apodization) to 1 (no apodization). Default to 1. cut (double): Map cut scale defined by cutmapsize = cut x mapsize, from 0 (full cut) to 1 (no cut). Default to 1. - Return:
W[x,y] (double): Window function, with bounds (nx,ny) - Usage:
W = flatsky.utils.window_sin(nx,ny,D,ap,cut):
-
flatsky.utils.
window_norm
(nx, ny, wind, num)¶ - Usage:
wn = flatsky.utils.window_norm(nx,ny,wind,num):
-
flatsky.utils.
window_norm_x
(nx, ny, W1, W2, num)¶ - Usage:
Wn = flatsky.utils.window_norm_x(nx,ny,W1,W2,num):
-
flatsky.utils.
rotation
(nx, ny, rot, QU, rtype)¶ - Usage:
rQU = flatsky.utils.rotation(nx,ny,rot,QU,rtype):
-
flatsky.utils.
get_angle
(nx, ny, D)¶ - Usage:
theta,phi = flatsky.utils.get_angle(nx,ny,D):
-
flatsky.utils.
cutmap
(ox, oy, cx, cy, omap)¶ - Usage:
cmap = flatsky.utils.cutmap(ox,oy,cx,cy,omap):


Rows and Columns
Simple example of rows and columns.
Col: 1, Row: 1
Col: 1, Row: 2
Col: 2, Row: 1
Col: 2, Row: 2
Horizontal Alignment
Examples of the possible horizontal alignments available in Vice.
Right
Left
Center
Stretch
Vertical Alignment
Examples of the possible vertical alignments available in Vice.
Top
Bottom
Middle
Stretch
Combo Alignment
Examples of the possible alignment combinations available in Vice.
Top/Left
Bottom/Center
Middle/Center
Top/Right
Multiple Children
Example of multiple children occupying one cell with alignments.
Top/Left
Bottom/Center
Middle/Center
Top/Right
Column Spanning
Example of column spanning.
Col: 1, Row: 1, Col Span: 2
Col: 3, Row: 1
Col: 1, Row: 2
Col: 2, Row: 2
Col: 3, Row: 2
Row Spanning
Example of row spanning.
Col: 1, Row: 1
Col: 2, Row: 1, Row Span: 2
Col: 3, Row: 1
Col: 1, Row: 2
Col: 3, Row: 2


---
layout: post
title: 2/24
date: '2013-02-24T22:10:00.001-07:00'
author: Jacob .
tags:
modified_time: '2013-02-24T22:10:55.437-07:00'
blogger_id: tag:blogger.com,1999:blog-6400085873105072120.post-764550099095439434
blogger_orig_url: http://www.svlark.com/2013/02/224_24.html
---
We took today off of house selling.
Audrey did lesson 70.


Show the world what an awesome guide you are by building a profile that will amaze both Tourists and Companies!
Get in touch with other guides, take part in exiting events, share knowledge, exchange industry secrets and make friends
From lone travelers to groups of tourists and Companies, everyone needs a great guide. So why not show them what you can do?
Turn each moment into an opportunity. By writing your contact details on your profile, jobs will start contacting you!


|
|||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Packages that use PDFileSpecification | |
| org.pdfbox.pdmodel.common | High level PD classes that are used throughout several packages are placed in the PDModel common package. |
| org.pdfbox.pdmodel.common.filespecification | The file specification package defines classes that are used for the PDF File Specification logic. |
| org.pdfbox.pdmodel.fdf | The fdf package will handle all of the logic used for FDF objects inside of the PDF/FDF document. |
| org.pdfbox.pdmodel.interactive.action.type | This package contains all of the available PDF action types. |
| org.pdfbox.pdmodel.interactive.annotation | The annotation package contains classes that work with PDF annotation elements. |
| Uses of PDFileSpecification in org.pdfbox.pdmodel.common |
| Methods in org.pdfbox.pdmodel.common that return PDFileSpecification | |
PDFileSpecification |
PDStream.getFile()
This will get the file specification for this stream. |
PDFileSpecification |
PDMemoryStream.getFile()
This will get the file specification for this stream. |
| Methods in org.pdfbox.pdmodel.common with parameters of type PDFileSpecification | |
void |
PDStream.setFile(PDFileSpecification f)
Set the file specification. |
void |
PDMemoryStream.setFile(PDFileSpecification f)
Set the file specification. |
| Uses of PDFileSpecification in org.pdfbox.pdmodel.common.filespecification |
| Subclasses of PDFileSpecification in org.pdfbox.pdmodel.common.filespecification | |
class |
PDComplexFileSpecification
This represents a file specification. |
class |
PDSimpleFileSpecification
A file specification that is just a string. |
| Methods in org.pdfbox.pdmodel.common.filespecification that return PDFileSpecification | |
static PDFileSpecification |
PDFileSpecification.createFS(COSBase base)
A file specfication can either be a COSString or a COSDictionary. |
| Uses of PDFileSpecification in org.pdfbox.pdmodel.fdf |
| Methods in org.pdfbox.pdmodel.fdf that return PDFileSpecification | |
PDFileSpecification |
FDFNamedPageReference.getFileSpecification()
This will get the file specification of this reference. |
PDFileSpecification |
FDFDictionary.getFile()
The source file or target file: the PDF document file that this FDF file was exported from or is intended to be imported into. |
| Methods in org.pdfbox.pdmodel.fdf with parameters of type PDFileSpecification | |
void |
FDFNamedPageReference.setFileSpecification(PDFileSpecification fs)
This will set the file specification for this named page reference. |
void |
FDFDictionary.setFile(PDFileSpecification fs)
This will set the file specification. |
| Uses of PDFileSpecification in org.pdfbox.pdmodel.interactive.action.type |
| Methods in org.pdfbox.pdmodel.interactive.action.type that return PDFileSpecification | |
PDFileSpecification |
PDActionRemoteGoTo.getFile()
This will get the file in which the destination is located. |
PDFileSpecification |
PDActionLaunch.getFile()
This will get the application to be launched or the document to be opened or printed. |
| Methods in org.pdfbox.pdmodel.interactive.action.type with parameters of type PDFileSpecification | |
void |
PDActionRemoteGoTo.setFile(PDFileSpecification fs)
This will set the file in which the destination is located. |
void |
PDActionLaunch.setFile(PDFileSpecification fs)
This will set the application to be launched or the document to be opened or printed. |
| Uses of PDFileSpecification in org.pdfbox.pdmodel.interactive.annotation |
| Methods in org.pdfbox.pdmodel.interactive.annotation that return PDFileSpecification | |
PDFileSpecification |
PDAnnotationFileAttachment.getFile()
Return the attached file. |
| Methods in org.pdfbox.pdmodel.interactive.annotation with parameters of type PDFileSpecification | |
void |
PDAnnotationFileAttachment.setFile(PDFileSpecification file)
Set the attached file. |
|
|||||||||||
| PREV NEXT | FRAMES NO FRAMES |


Google Pixel 6 to have new AI Tensor chip
Custom-building its own system on a chip.
Google is set to launch its new phones, the Pixel 6 and Pixel 6 Pro, powered by a new artificial intelligence (AI) chip.
Known as Tensor, it’s the company’s first custom-built, system on a chip (SoC) that will use AI and machine learning (ML) to guide the phone’s operations.
“It’s not simply about adding more computing resources, it’s about using that ML to unlock specific experiences for our Pixel users,” Google said on its blog.
Google sees AI as underpinning its innovations, but up until now computing limitations had prevented it from fully pursuing its mission, so it worked to build its own technology platform for mobile that enabled it to bring its most innovative AI and ML to the Pixel.
“We set out to make our own System on a Chip (SoC) to power Pixel 6. And now, years later, it’s almost here,” the company said.
Launching in the US autumn and light on technical detail at this stage, Google is promising big things with the new Pixel, including the Tensor SoC and Android 12, billed as its fastest on internal benchmark tests, smartest and most secure Pixel yet. “A new design that combines the same beautiful aesthetic across software and hardware,” it promises.
With Tensor, Google has customised it to run Google's computational photography models, bringing new features and improvements to existing ones.
The rear camera system will get a boost from improved sensors and lenses, now too big to fit into the traditional square, requiring a new design that gives the whole camera system a new home with the camera bar. It’s also getting a security boost, with a new security core and Titan M2, claiming the most layers of hardware security in any phone, based on a count of independent hardware security subsystems and components.


I am a PhD student and Research Project Assistant at The State University of New York at Binghamton. My research is focused on building and enforcing security features for proprietry software, especially when source code is not available. My advisor is Dr. Aravind Prakash
Research Interests: Software Security, Reverse Engineering and Binary Analysis
My resume can be found here


Structural parameters for SrCo 0.95Ru 0.05O 3−δ refined from neutron powder diffraction (NPD) data at 25 °C.


About Me
This is Bhagia Sheri, currently enrolled in the final year of the Software Engineering Department, Mehran University of Engineering and Technology Jamshoro and working on enhancing the programming skills. I strongly believe in solving issues with better communication & objective reasoning that's why I have started working on projects since my first year. Till now I have worked so many projects and in the future, I am eager to work on projects with a huge impact. From my earlier internships' experience, I can say that Leadership, Project Management, Problem Solving, Time Management, Teamwork, and Effective Communications are my strengths in a professional environment.
What I do?
Final Year Student, MUET Jamshoro
Coding is my passion
Social Worker
Internships & Training Experience


A FISTFUL OF DOLLARS (PER UN PUGNO DI DOLLARI) (director/writer: Sergio Leone; cinematographer: Massimo Dallamano; editor: Roberto Cinquini; cast: Clint Eastwood (The Man With No Name - Joe), Marianne Koch (Marisol), Gian Maria Volonté (Ramon Rojo), Wolfgang Lukschy (John Baxter), Sieghardt Rupp (Esteban), Joseph Egger (Piripero), Antonio Prieto (Benito Rojo), Pepe Calvo (Silvanito), Margarita Lozano (Consuelo), Mario Brega (Chico), Bruno Carotenuto (Antonio), Benito Stefanelli (Rubio); Runtime: 96; United Artists; 1964-Italy/W. Ger /Sp.)
Reviewed by Dennis Schwartz
A reworking of Kurosawa's "Yojimbo (61)." This Italian made western, filmed in Spain, began the craze of so-called Spaghetti Westerns. Clint Eastwood plays 'The Man With No Name,' in the first of the three films made with the same theme (the others were: "For a Few Dollars More"(65) and "The Good, the Bad, and the Ugly" (1966)). Clint was on TV doing the Rawhide series and jumped at the chance to go to Europe to make these films when both James Coburn and then Charles Bronson were offered the parts by director Sergio Leone, but wanted more than the $15,000 available. The films became popular in Europe where Clint became a big star, and three years later United Artists bought all three of 'The Man With No Name' films and showed them with great success in America. The film is a no message one, where violence is glorified by the hero who is as amoral as the villains. This kind of attitude changed the way Westerns were made. It's an entertaining film, gore and all, its only drawbacks being the poor dubbing job and that Leone hasn't perfected all his moves yet in a smooth way. Yet this film, not as rewarding as his others, still has the style of the director's later works, plus the same themes of graphic violence, a laconic hero, and the thrill of gunfights galore.
Clint arrives in the dusty Mexican border town of San Miguel where visitors just don't come without wanting something illegal. An old bell-ringer tells the newcomer that in this town folks get to be either rich or dead. Clint while riding through town on his mule is shot at by the gunmen of the Baxter clan. He soon learns from bartender Silvanito (Pepe Calvo) that there are two warring gangs in town: the Baxters and the Rojos. They control the gunrunning and liquor business, and are in an uneasy truce.  The rivals are the Rojo brothers: Ramon (Gian Maria Volonté), Esteban (Sieghardt Rupp) and Benito (Antonio Prieto). Their most trusted gunman is Chico (Brega). Both sides have many hired guns, but the Rojo family is the stronger clan. Clint decides he's clever enough to play them off one against the other, and try to get all the money he can from both sides. He hires himself out with the Rojos, and to earn his pay he kills the gunmen who shot at him. Clint chomps at the end of his cigar without smoking it, says little, wears a Mexican poncho, and is always with his trusted .45s. He makes an imposing figure, as he's tall, bearded, and mean looking.
 He steals two calvary corpses and tells each side to watch out for the other, and thereby gets them into a shooting war. This results in lots of corpses for the friendly coffin maker in town. But this scene was shot in a shoddy way, as it was hard to comprehend that the two gangs were so stupid that they would so easily believe that the stiffs they were fighting over were real.
Clint does a good deed by rescuing the beautiful Marisol (Koch), who is being held hostage by Ramon. He slays the Rojo gunmen guarding her and returns her to her son and husband.  Then Clint returns to get into a shootout with the Rojos, saving Ramon for last. He then rides off with the gold, instead of with the pretty girl.
In this Western parody, there's some humor behind all the choreographed violence and there's also a passable Ennio Morricone's score to instill a sense of melodrama. What makes this mythical film noteworthy, is that it serves an historical purpose as the start of a new trend in making Westerns.
REVIEWED ON 6/10/2001 GRADE: B
Dennis Schwartz: "Ozus' World Movie Reviews"
http://www.sover.net/~ozus
<EMAIL_ADDRESS>© ALL RIGHTS RESERVED DENNIS SCHWARTZ
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


KnockoutJS context debugger options
If you experience crashes you propably have a non serializable viewmodel. You can turn off the serialization. The extension default does ko.toJS(ko.dataFor($0)) and ko.toJS(ko.contextFor($0).$root)
Serialize (provides the best visualization)
If you really don't like the extra panel you can disable it here.
Show KnockoutJS panel.
Enable editBindings, edit$data, edit$root
Add snippets for
manipulation viemodel/binding
for the selected DOM element.
Donation
I appreciate your work €1,00 EUR
Have a beer €2,50 EUR
Increased developer happiness €5,00 EUR
Could not work without it €10,00 EUR
Enterprise €50,00 EUR
Saved


| MATLAB 文件帮助: cv.VideoCapture/read | 查看 cv.VideoCapture/read 的代码 | Index |
read Grabs, decodes and returns the next video frame
frame = cap.read()
frame = cap.read('OptionName',optionValue, ...)
The method combines cv.VideoCapture.grab and cv.VideoCapture.retrieve in one call. This is the most convenient method for reading video files or capturing data from decode and return the just grabbed frame. If no frames has been grabbed (camera has been disconnected, or there are no more frames in video file), the function return an empty matrix.
| Access | public |
| Sealed | false |
| Static | false |


Calorie Watcher
Welcome to Calorie Watcher Account
Please login to Calorie Watcher
Calorie Watcher
Username
Password
Login
Remember me
Sign up for the free Calorie Watcher account


Amazing workflow
As the name already says RSSV Workflow is a front-end environment that facilitates the creation of your application with a series of preconfigured tools. We have as example a local server that recharges automatically every time you change a css, html or javascript file.
Some Tools inside RSSV:
Of course, just wait dear friend.
Of course you can contribute. But have some rules with we need to follow for a better organization. The rules:
Example: Issues/15


| Vendor Name | FUJITSU CONSULTING CANADA INC. |
|---|---|
| Reference Number |<PHONE_NUMBER> |
| Contract Date | 2012-02-03 |
| Description of Work | 1283 - Computer Equipment-Client Computing Domain-Desktop/Personal/Portable (Includes related parts and peripherals) |
| Delivery Date | 2015-05-05 |
| Contract Value | $22,122,758.89 |
| Comments | Amendment(s) to previously disclosed contract./Competitively sourced./Procurement of biometric goods and related services between CIC and CBSA./Contract with task authorizations.Realized amount of contract contingent upon number of task authorizations issued. May be less than amount proactively disclosed./Multi-year contract./Awarded by PWGSC. |


Course Name
Team Number: Minimun:3, Maximum:6
Search Team
| Groupname | No.of people | Detail | Send Request |
|---|---|---|---|
| TeamK | 3 |
Search Person
| Groupname | Team Belong | Detail | Send Request |
|---|---|---|---|
| Girl | TeamC |
Team Number: Minimun:3, Maximum:6
| Groupname | No.of people | Detail | Send Request |
|---|---|---|---|
| TeamK | 3 |
| Groupname | Team Belong | Detail | Send Request |
|---|---|---|---|
| Girl | TeamC |


Susy3 API Functions
These three functions form the core of Susy’s layout-building grid API.
- Use
span()
andgutter()
to return any grid-width, and apply the results wherever you need them: CSSwidth
,margin
,padding
,flex-basis
,transform
, etc. - For asymmetrical-fluid grids,
slice()
can help manage your nesting context.
All three functions come with an unprefixed alias by default,
using the susy
import.
Import the susy-prefix
partial instead,
if you only only want prefixed versions of the API.
This is a thin syntax-sugar shell around
the “Su” core-math functions: su-span
, su-gutter
, and su-slice
.
If you prefer the more constrained syntax of the math engine,
you are welcome to use those functions instead.
Related
@function susy-span()
@function susy-gutter()
@function susy-slice()
@function su-span()
@function su-gutter()
@function su-slice()
Shorthand
All functions draw on the same shorthand syntax in two parts,
seperated by the word of
.
Span Syntax: <width>
[<location>
<spread>
]
The first part describes the span width, location, and spread in any order. Only the width is required:
span(2)
will return the width of 2 columns.span(3 wide)
will return 3-columns, with an additional gutter.- location is only needed with asymmetrical grids,
where
span(3 at 2)
will return the width of specific columns on the grid. Since these are functions, they will not handle placement for you.
Context Syntax: [of <columns> <container-spread> <gutters>]
The second half of Susy’s shorthand describes the grid-context – available columns, container-spread, and optional gutter override – in any order. All of these settings have globally-defined defaults:
span(2 of 6)
will set the context to a slice of 6 columns from the global grid. More details below.span(2 of 12 wide)
changes the container-spread as well as the column-context.span(2 of 12 set-gutters 0.5em)
will override the global gutters setting for this one calculation.
A single unitless number for columns
will be treated as a slice of the parent grid.
On a grid with columns: susy-repeat(12, 120px)
,
the shorthand of 4
will use the parent 120px
column-width.
You can also be more explicit,
and say of susy-repeat(4, 100px)
.
If you are using asymmetrical grids,
like columns: (1 1 2 3 5 8)
,
Susy can’t slice it for you without knowing which columns you want.
The slice
function accepts exactly the same syntax as span
,
but returns a list of columns rather than a width.
Use it in your context like of slice(first 3)
.
@function susy-span()
aliased as span()
This is the primary function in Susy —
used to return the width of a span across one or more columns,
and any relevant gutters along the way.
With the default settings,
span(3)
will return the width of 3 columns,
and the 2 intermediate gutters.
This can be used to set the width
property of grid elements,
or margin
and padding
to push, pull, and pad your elements.
- This is a thin syntax-sugar shell around
the core-math
su-span()
function. - The un-prefixed alias
span()
is available by default.
Parameters & Return
$span: (list)
Shorthand expression to define the width of the span, optionally containing:
- a count, length, or column-list span.
at $n
,first
, orlast
location on asymmetrical grids, whereat 1 == first
, andlast
will calculate the proper location based on columns and span.narrow
,wide
, orwider
for optionally spreading across adjacent gutters.of $n <spread>
for available grid columns and spread of the container. Span counts likeof 6
are valid in the context of symmetrical grids, where Susy can safely infer a slice of the parent columns.- and
set-gutters $n
to override global gutter settings.
$config: () (map)
Optional map of Susy grid configuration settings.
See $susy
documentation for details.
@return (length)
Calculated length value, using the units given,
or converting to %
for fraction-based grids,
or a full calc
function when units/fractions
are not comparable outside the browser.
Examples
.foo {
// the result is a bit under 50% to account for gutters
width: susy-span(6 of 12);
}
.foo {
width: 49.15254%;
}
.foo {
width: susy-span(3 at 3 of (1 2 3 5 8));
}
.foo {
width: 82.5%;
}
@function susy-gutter()
aliased as gutter()
The gutter function returns
the width of a single gutter on your grid,
to be applied where you see fit –
on margins
, padding
, transform
, or element width
.
- This is a thin syntax-sugar shell around
the core-math
su-gutter()
function. - The un-prefixed alias
gutter()
is available by default.
Parameters & Return
$context: null (list | number)
Optional context for nested gutters,
including shorthand for
columns
, gutters
, and container-spread
(additional shorthand will be ignored)
$config: () (map)
Optional map of Susy grid configuration settings.
See $susy
documentation for details.
@return (length)
Width of a gutter as %
of current context,
or in the units defined by column-width
when available
Examples
.floats {
float: left;
width: span(3 of 6);
margin-left: gutter(of 6);
}
.floats {
float: left;
width: 48.27586%;
margin-left: 3.44828%;
}
.flexbox {
flex: 1 1 span(3 wide of 6 wide);
padding: gutter(of 6) / 2;
}
.flexbox {
flex: 1 1 50%;
padding: 1.72414%;
}
Used By
@function gutter()
@function susy-slice()
aliased as slice()
Working with asymmetrical grids (un-equal column widths)
can be challenging –
expecially when they involve fluid/fractional elements.
Describing a context of (15em 6em 6em 6em 15em)
is a lot
to put inside the span or gutter function shorthand.
This slice function returns a sub-slice of asymmetrical columns to use
for a nested context.
slice(3 at 2)
will give you a subset of the global grid,
spanning 3 columns, starting with the second.
- This is a thin syntax-sugar shell around
the core-math
su-slice()
function. - The un-prefixed alias
slice()
is available by default.
Parameters & Return
$span: (list)
Shorthand expression to define the subset span, optionally containing:
at $n
,first
, orlast
location on asymmetrical grids;of $n <spread>
for available grid columns and spread of the container- Span-counts like
of 6
are only valid in the context of symmetrical grids - Valid spreads include
narrow
,wide
, orwider
- Span-counts like
$config: () (map)
Optional map of Susy grid configuration settings.
See $susy
documentation for details.
@return (list)
Subset list of columns for use for a nested context
Example
$context: susy-slice(3 at 3 of (1 2 3 5 8));
/* $context: #{$context}; */
/* $context: 3 5 8; */
Used By
@function slice()
Building Grids
The web has come a long way since the days of double-margin-hacks and inconsistent subpixel rounding. In addition to floats and tables, we can now use much more powerful tools, like flexbox and CSS grid, to build more interesting and responsive layouts.
With Susy3, we hope you’ll start moving in that direction. You can still build classic 12-column Grid Systems, and we’ll help you get there, but Susy3 is primarily designed for a grid-math-on-demand approach to layout: applying our functions only where you really need grid math. Read the intro article by OddBird for more details.
Examples
.float {
width: span(3);
margin-right: gutter();
}
.float {
width: 73.68421%;
margin-right: 5.26316%;
}
.flexbox {
flex: 1 1 span(3);
// half a gutter on either side…
padding: 0 gutter() / 2;
}
.flexbox {
flex: 1 1 73.68421%;
padding: 0 2.63158%;
}
.push-3 {
margin-left: span(3 wide);
}
.pull-3 {
margin-left: 0 - span(3 wide);
}
.push-3 {
margin-left: 78.94737%;
}
.pull-3 {
margin-left: -78.94737%;
}
// markup example:

[data-span] {
float: left;
&:not([data-span*='last']) {
margin-right: gutter();
}
}
@for $span from 1 through length(susy-get('columns')) {
[data-span*='#{$span}'] {
width: span($span);
}
}
[data-span] {
float: left;
}
[data-span]:not([data-span*='last']) {
margin-right: 5.26316%;
}
[data-span*='1'] {
width: 21.05263%;
}
[data-span*='2'] {
width: 47.36842%;
}
[data-span*='3'] {
width: 73.68421%;
}
[data-span*='4'] {
width: 100%;
}


A robust model for the generative
bird egg patterning.
A biologically informed model for generating realistically patterned bird eggs
for experiments on avian sensory ecology.
Grasshopper with C#, 3D printed. For the Stoddard Lab at Princeton.
S


Get in Touch
Interior Gallery
All Designs
Fireplace
Lounge
Kitchen
Kitchen Shelving
Bedroom 2
Dining Room
Playroom
Bedroom 1
Living Room 5
Living Room 5 Shelves
Guest Room W
Basement Rec Room
Have a Question?
call or text<PHONE_NUMBER>
email
teresa@habitatstaging.com


Thank you very much for your support!
Prices:
Individuals: GBPs Â£100 per year
Academic Libraries, Universities, Research Centers: GBPs Â£400 per year
Library Consortia, Library Associations: GBPs Â£4000 per year
Aggregators and other Service Providers: GBPs Â£5000 per year
The fastest and most secure way to pay is via PayPal.
or you can complete the form below.


All Figures -- Frame 0 at time t = 0.00000
< <
<
Index
>
> >
Click on a figure to enlarge
Other frames:
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16


Update: A new LFE docs site is under development. Find out how you can help!
Below are links to the LFE man pages (plain text) maintained in the LFE repository:
The LFE Edition
The LFE Edition
The history section got too big, so we moved it into its own page. Please visit the LFE-related history page.
Our presentations page has recorded video of LFE talks, slide decks, and screencasts.
See the examples page for a list of links which provide access to a great number of LFE examples and real-world projects which you can both use and learn from.


Host
Connect
port
Host Server
ip
port
Connect
Send Messages
Receive Messages
Send Message
Last message received:
Enable auto typing messages
searching for connection
connection established


|
Miss
You Love
(Silverchair) |
|
Millionaire
say
Got a big shot deal And thrown it all away but But I'm not too sure How I'm supposed to feel Or what I'm supposed to say But I'm not, not sure, Not too sure how it feels To handle every day And I miss you love Make room for the prey 'Cause I'm coming in With what I wanna say but It's gonna hurt And I love the pain A breeding ground for hate but... I'm not, not sure, Not too sure how it feels To handle everyday Like the one that just past In the crowds of all the people Remember today I've no respect for you And I miss you love And I miss you love I love the you love But I hate the way I'm supposed to love you back It's just a fad Part of the teenage angst brigade and I'm not, not sure, Not too sure how it feels To handle everyday Like the one that just past In the crowds of all the people Remember today I've no respect for you And I miss you love And I miss you love Remember today I've no respect for you And I miss you love And I miss use love I love the you love But I hate the way I'm supposed to love you back |


{% extends "base.html" %} {% block dropdown %} {% endblock %} {% block content %}
| CaseID: | {{ brother.case_ID }} | ||
| Birthday: | {{ brother.birthday }} | ||
| Hometown: | {{ brother.hometown }} | ||
| Roster Number: | {{ brother.roster_number }} | ||
| Semester Joined: | {{ brother.semester_joined }} | ||
| School Status: | {{ brother.get_school_status_display }} | ||
| Brother Status: | {{ brother.get_brother_status_display }} | ||
| Standing Committee: | {{ brother.get_standing_committee_display }} | ||
| Operational Committee: | {{ brother.get_operational_committee_display }} | ||
| Major: | {{ brother.major }} | ||
| Minor: | {{ brother.minor }} | ||
| T-Shirt Size: | {{ brother.t_shirt_size }} | ||
| Phone Number: | {{ brother.phone_number }} | ||
| Emergency Contact: Phone Number: |
{{ brother.emergency_contact }} {{ brother.emergency_contact_phone_number }} |
||
| Room Number: | {{ brother.room_number }} | {% else %}Address: | {{ brother.address }} | {% endif %}
| Event | Date | |
| {{ event.name }} | {{ event.date }} | {{ attendance }} |
| Potential New Member: | Case ID: | Phone Number: | Contact Type |
| {{ pnm.first_name }} {{ pnm.last_name }} | {{ pnm.case_ID }} | {{ pnm.phone_number }} | {% if pnm.primary_contact == brother %} Primary {% elif pnm.secondary_contact == brother %} Secondary {% else %} Tertiary {% endif %} |
| Event | Date |
| {{ event.name }} | {{ event.date }} |
| Event This Semester | Date | Rush |
| {{ event.name }} | {{ event.date }} | {{ event.rush }} |
| Event Next Semester | Date | Rush |
| {{ event.name }} | {{ event.date }} | {{ event.rush }} |
| Operational: | Date: | Minutes: | |
| {{ meeting.get_committee_display }} | {{ meeting.datetime.date }} - {{ meeting.datetime.time }} | {% if meeting.minutes %}link | {% else %}{% endif %} |
| Standing: | Date: | Minutes: | |
| {{ meeting.get_committee_display }} | {{ meeting.datetime.date }} - {{ meeting.datetime.time }} | {% if meeting.minutes %}link | {% else %}{% endif %} |
| Event | Date |
| {{ event.name }} | {{ event.date }} |


https://attack.mitre.org/wiki/Main_Page
Tactics
Initial Access
Persistence
Privilege Escalation
Defense Evasion
Credential Access
Discovery
Lateral Movement
Execution
Collection
Exfiltration
Command and Control
Techniques
Technique Matrix
All Techniques
Windows
Linux
macOS


I was intrigued by software and machine learning while developing a data processing tool for environmental risk assessment. I saw their magical power and amazing potential in making a huge difference. As a life-long learner, my past experience has prepared me with both solid knowledge and project experience varying from web application, algorithm design to natural language processing.
The technology is merely a tool, what matters most is the purpose behind it. I hope to exert my technical abilities to building something meaningful and benefiting those who have dreams.
View ResumeA web application for users to submit URLs for detecting faces in images
Front end was built via React and back end was developed using Express with user information stored in PostgreSQL database
A web application to search for github users and display their repos
A web application for friends from CU-Boulder to search contact information and get connected with each other
<EMAIL_ADDRESS>Connect with Me


Power optimisation
For the emonTx to run of two AA's for as long as possible the Mains AC: non-invasive 3.0 energy monitoring circuit and code was optimized for low power. See below for brief account of changes.
1. Increase CT circuit voltage divider resistor values from 10K to 470K
This reduced quiescent power consumption across the resistors from 0.25mA to 5.3uA at 5V
2. Reduce number of samples from 6000 to 1490
This reduced the time needed for a reading from over 1s to 332ms. As the number of samples are reduced it is important that the time taken for the samples is an integer of the period of the waveform.
The period (one wavelength) of mains 50Hz is 20ms. Each samples was measured to take 0.188ms. This means that 106.4 samples/wavelength are possible. 1480 samples takes 280.14ms which is 14 wavelengths.
3. Put Atmega 328 into sleep mode in between readings
We followed this example to use the watchdog timer to put the device into sleep mode for 4 seconds (watchdog value 8) in between readings. In sleep mode the ATmega 328 consumes 0.03mA with an RF transmitter and CT monitor circuit. The power consumption during readings is 13mA
Rough battery life estimation calculations
Therefore the device is on for 332mS consuming 13mA then asleep for 4s consuming 0.03mA
This gives an on off ratio of 4/0.332=12. The battery life should be extended by this amount.
An AA alkaline battery has between 2000-3000 mAhrs of capacity. If the device was not put into sleep mode the battery would last for 2500/13=192hrs=8 days.
Since the device is in sleep mode for a proportion of this time the average power consumption is 13/12=1.083mA plus the power consumption while in sleep mode of 0.03mA
This should give a battery life of 2500/(1.083+0.03)=2246hrs= 93.6 days = 3 months
In reality the battery will not last this long, at least not using two AA's since the Atmega 328 will stop working due to low voltage before the batteries are depleted. Using three AA's would be better but our enclosure does not allow for this. The ATmega 328 should work down to 1.8V.
Real world battery life test
A real-world test was setup to test the above calculation.
Here was the result:
The test actually ran for 5 months from two AA batteries! A great success. The test setup actually used a pair of simple RF modules not the RFM12B transceiver module which was used in the final design. According to the datasheets the power consumption for the two RF modules are similar, if not slightly less. We are therefore expecting battery life to be similar, or even slightly longer.
Burden Resistor Power Dissipation
Normal expected peak current through 18 ohm burden resistor when using SCT-013-000 CT measuring 100A = 70.7mA
Peak power dissipation in burden resistor = Peak V * Peak I = 1.65 * 70.7 =115.5mW = 0.1155W


Maxwell Road Hawker Centre is located in the heart of Chinatown with over 100 stalls. There are many popular
food stalls here like Tian Tian Hainanese Chicken Rice, Zhen Zhen Porridge (which I absolutely love but hate to queue)
and Char Kway Teow from Marina South Delicious Food Stall.
Address: 1 Kadayanallur St S069184
Opening Hours: 0800 - 2200 daily
Maxwell Road Hawker Centre is within walking distance of Tanjong Pagar MRT.
Located above a wet market, this is one hawker centre I often visit. Though it is smaller compared to other hawker centres,
they have a wide variety of food options from duck rice, satay bee hoon, chicken wings to what it’s widely known for - fried carrot cake.
In the day, stalls selling food like chee cheong fun, meat dumplings and breakfast snacks are opened. When night falls, stalls
selling BBQ seafood and satay open.
Address: 116 Upper Bukit Timah Road, Singapore 588172
Unlike most of the hawker centres listed here, Chomp Chomp mainly operates at night selling dinner/supper favorites like satay,
hokkien mee and BBQ seafood. This is one of the most famous food centres in Singapore though it can get quite stuffy inside
with the poor air ventilation.
Address: 20 Kensington Park Road, Singapore 557269
Opening Hours: 6pm - 12am
Tekka Centre remains a landmark of Little India where different ethnicities congregate. Though many Indians are seen here,
you can also find Chinese stallholders who speak fluent Tamil. The ground floor is a hawker centre which contains more
Muslim and Indian food stalls than the usual hawker centres.
Tekka Centre is situated just outside Little India Station which makes it very convenient to visit
Address: 665 Buffalo Rd, L1 Tekka Centre, Singapore 210665
Opening Hours: Daily 06:30 – 17:00


|
Ogre_glTF
glTF import library for Ogre
|
Class that hold the loaded content of a glTF file and that can create Ogre objects from it. More...
#include <Ogre_glTF.hpp>
Classes | |
| struct | impl |
| Implementaiton of the adapter. More... | |
Public Member Functions | |
| loaderAdapter () | |
| This will also initialize the "pimpl" structure. | |
| ~loaderAdapter () | |
| This clear the pimpl structure. | |
| loaderAdapter (const loaderAdapter &)=delete | |
| Deleted copy constructor : non copyable class. | |
| loaderAdapter & | operator= (const loaderAdapter &)=delete |
| Deleted assignment constructor : non copyable class. | |
| Ogre::MeshPtr | getMesh () const |
| Return the mesh loaded from the glTF file. | |
| Ogre::HlmsDatablock * | getDatablock (size_t index=0) const |
| size_t | getDatablockCount () |
| Return the number of datablock stored. | |
| ModelInformation::ModelTransform | getTransform () |
| Get the local transform to apply to the node to align the model with what you would expect. | |
| Ogre::Item * | getItem (Ogre::SceneManager *smgr) const |
| loaderAdapter (loaderAdapter &&other) noexcept | |
| loaderAdapter & | operator= (loaderAdapter &&other) noexcept |
| Move assignment operator. | |
| bool | isOk () const |
| Return the current state of the adapter. | |
| std::string | getLastError () const |
| Return the last error generated by the underlying glTF loading library. | |
Friends | |
| class | glTFLoader |
Class that hold the loaded content of a glTF file and that can create Ogre objects from it.
Definition at line 90 of file Ogre_glTF.hpp.
|
noexcept |
Move constructor : object is movable
| other | object to move |
Definition at line 91 of file Ogre_glTF.cpp.
| Ogre::HlmsDatablock * loaderAdapter::getDatablock | ( | size_t | index = 0 | ) | const |
Return one of the datablocks loaded from the gltf file.
| index | of the datablocks used. In a multi-material file, it should be one different per primitive (submesh). |
Definition at line 87 of file Ogre_glTF.cpp.
Referenced by getItem(), Ogre_glTF::glTFLoader::getMeshFromFileSystem(), Ogre_glTF::glTFLoader::getMeshFromResource(), and Ogre_glTF::glTFLoader::getModelData().
| Ogre::Item * loaderAdapter::getItem | ( | Ogre::SceneManager * | smgr | ) | const |
Construct an item for this object
| smgr | pointer to the scene manager where we are creating the item |
Definition at line 58 of file Ogre_glTF.cpp.
References getDatablock(), getMesh(), and isOk().
Referenced by Ogre_glTF::glTFLoader::getItemFromFileSystem(), and Ogre_glTF::glTFLoader::getItemFromResource().


Relive Your Personal Pokémon Memories With This Online Journey Builder Tool
And share them with the world
by Ryan CraddockThe Pokémon Company has released a quirky new tool on its official Japanese website, allowing fans of the series to relive their favourite moments from the last couple of decades.
You can access the tool right here; the whole thing is in Japanese, but you'll just about be able to get by with the standard (if pretty poor) translation tool available within the Google Chrome browser. Fans are asked to select the regions they've discovered - so whether you started playing Pokémon way back in the old days with Red and Blue, or much more recently with Sun and Moon, you'll definitely be covered.
From there, it's a simple case of choosing highlights from each game such as your starter Pokémon, memorable battles, and memorable story scenes. Once you're done, a shareable video will be created which you can post to your social media platform of choice. You can also generate a standard URL for your video, so feel free to grab those and post them in our comment section below.
You'll notice that the end of the video also adds in a few scenes from the upcoming Pokémon Sword and Shield, which we're sure plenty of you will be tucking into next week. Can you believe the games are out in exactly a week's time?
As we mentioned before, make sure to share your videos with us below and tell us all about your favourite Pokémon memories.
[via greatstory.pokemon.co.jp, vooks.net]


This page explains how to use to Storm to consume items from a Kestrel cluster.
Preliminaries
### Storm This tutorial uses examples from the storm-kestrel project and the storm-starter project. It’s recommended that you clone those projects and follow along with the examples. Read Setting up development environment and Creating a new Storm project to get your machine set up. ### Kestrel It assumes you are able to run locally a Kestrel server as described here.
Kestrel Server and Queue
A single kestrel server has a set of queues. A Kestrel queue is a very simple message queue that runs on the JVM and uses the memcache protocol (with some extensions) to talk to clients. For details, look at the implementation of the KestrelThriftClient class provided in storm-kestrel project.
Each queue is strictly ordered following the FIFO (first in, first out) principle. To keep up with performance items are cached in system memory; though, only the first 128MB is kept in memory. When stopping the server, the queue state is stored in a journal file.
Further, details can be found here.
Kestrel is: * fast * small * durable * reliable
For instance, Twitter uses Kestrel as the backbone of its messaging infrastructure as described [here] (http://bhavin.directi.com/notes-on-kestrel-the-open-source-twitter-queue/).
Add items to Kestrel
At first, we need to have a program that can add items to a Kestrel queue. The following method takes benefit of the KestrelClient implementation in storm-kestrel. It adds sentences into a Kestrel queue randomly chosen out of an array that holds five possible sentences.
``` private static void queueSentenceItems(KestrelClient kestrelClient, String queueName) throws ParseError, IOException {
String[] sentences = new String[] {
"the cow jumped over the moon",
"an apple a day keeps the doctor away",
"four score and seven years ago",
"snow white and the seven dwarfs",
"i am at two with nature"};
Random _rand = new Random();
for(int i=1; i<=10; i++){
String sentence = sentences[_rand.nextInt(sentences.length)];
String val = "ID " + i + " " + sentence;
boolean queueSucess = kestrelClient.queue(queueName, val);
System.out.println("queueSucess=" +queueSucess+ " [" + val +"]");
}
} ```
Remove items from Kestrel
This method dequeues items from a queue without removing them. ``` private static void dequeueItems(KestrelClient kestrelClient, String queueName) throws IOException, ParseError { for(int i=1; i<=12; i++){
Item item = kestrelClient.dequeue(queueName);
if(item==null){
System.out.println("The queue (" + queueName + ") contains no items.");
}
else
{
byte[] data = item._data;
String receivedVal = new String(data);
System.out.println("receivedItem=" + receivedVal);
}
} ```
This method dequeues items from a queue and then removes them. ``` private static void dequeueAndRemoveItems(KestrelClient kestrelClient, String queueName) throws IOException, ParseError { for(int i=1; i<=12; i++){
Item item = kestrelClient.dequeue(queueName);
if(item==null){
System.out.println("The queue (" + queueName + ") contains no items.");
}
else
{
int itemID = item._id;
byte[] data = item._data;
String receivedVal = new String(data);
kestrelClient.ack(queueName, itemID);
System.out.println("receivedItem=" + receivedVal);
}
}
} ```
Add Items continuously to Kestrel
This is our final program to run in order to add continuously sentence items to a queue called sentence_queue of a locally running Kestrel server.
In order to stop it type a closing bracket char ‘]’ in console and hit ‘Enter’.
``` import java.io.IOException; import java.io.InputStream; import java.util.Random;
import backtype.storm.spout.KestrelClient;
import backtype.storm.spout.KestrelClient.Item;
import backtype.storm.spout.KestrelClient.ParseError;
public class AddSentenceItemsToKestrel {
/**
* @param args
*/
public static void main(String[] args) {
InputStream is = System.in;
char closing_bracket = ']';
int val = closing_bracket;
boolean aux = true;
try {
KestrelClient kestrelClient = null;
String queueName = "sentence_queue";
while(aux){
kestrelClient = new KestrelClient("localhost",22133);
queueSentenceItems(kestrelClient, queueName);
kestrelClient.close();
Thread.sleep(1000);
if(is.available()>0){
if(val==is.read())
aux=false;
}
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
catch (ParseError e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("end");
}
} ``` ## Using KestrelSpout
This topology reads sentences off of a Kestrel queue using KestrelSpout, splits the sentences into its constituent words (Bolt: SplitSentence), and then emits for each word the number of times it has seen that word before (Bolt: WordCount). How data is processed is described in detail in Guaranteeing message processing.
TopologyBuilder builder = new TopologyBuilder();
builder.setSpout("sentences", new KestrelSpout("localhost",22133,"sentence_queue",new StringScheme()));
builder.setBolt("split", new SplitSentence(), 10)
.shuffleGrouping("sentences");
builder.setBolt("count", new WordCount(), 20)
.fieldsGrouping("split", new Fields("word"));
Execution
At first, start your local kestrel server in production or development mode.
Than, wait about 5 seconds in order to avoid a ConnectException.
Now execute the program to add items to the queue and launch the Storm topology. The order in which you launch the programs is of no importance.
If you run the topology with TOPOLOGY_DEBUG you should see tuples being emitted in the topology.


Web Developer
A Web developer who loves to create Web Applications that are functional and beautiful at the same time. You will find me either learning about MEAN Stack or building graphics on Illustrator.
<EMAIL_ADDRESS>abhishekp1996
Copyright © Abhishek Pathak 2017.
Made with ❤ and Brackets
Powered by Jekyll. All code MIT License.


Since δΦ is independent of the velocity in the particle coaordinates, the ﬁrst term (adiabatic term) in expression (191) is trivial and the velocity integration can be readily performed (assume F0 is Maxwellian), giving
which is called adiabatic response. Next, let us perform the gyro-averaging and the velocity integration of the second term in expression (191), i.e.,|
| (201) |
In order to perform the gyro-averaging of δΦ, we Fourier expand δΦ in space as
|
| (202) |
and then express x in terms of the guiding center variables (X,v) since the gyro-averaging is taken by holding X rather than x constant. The guiding-center transformation gives
|
| (203) |
Using expressions (202) and (203), the gyro-average of δΦ is written as
When doing the gyro-averaging, X is hold constant and thus e∥(X) is also constant. Then it is straightforward to deﬁne the gyro-angle α. Let k⊥ deﬁne one of the perpendicular direction 1, i.e., k⊥ = k⊥1. Then another perpendicular basis vector is deﬁned by 2 = e∥×1. Then v⊥ is written as v⊥ = v⊥(1 cosα + 2 sinα), which deﬁnes the gyro-angle α. Then the blue expression in Eq. (204) is written as Then the gyro-averaging in expression (204) is written as|
| (207) |
Next, we need to perform the integration in velocity space, which is done by holding x (rather than X) constant. Therefore, it is convenient to transform back to particle coordinates. Using X = x + v ×, expression (207) is written as
|
| (208) |
Then the velocity integration is written as
Similar to Eq. (205), except for now at x rather than X, ik ⋅ v × is written as|
| (210) |
Since this is at x rather than X, k⊥, v⊥, and Ω are diﬀerent from those appearing in expression (205). However, since this diﬀerence is due to the variation of the equilibrium quantity e∥∕Ω in a Larmor radius, and thus is small and is ignored in the following.
Plugging expression (210) into expression (209) and using dv = v⊥dv⊥dv∥dα, we get
Note that ∂F0∕∂𝜀 is independent of the gyro-angle α in terms of guiding-center variables. When transformed back to particle coordinates, X contained in ∂F0∕∂𝜀 will introduce α dependence via X = x + v ×. This dependence on α is weak since the equilibrium quantities can be considered constant over a Larmor radius distance evaluated at the thermal velocity. Therefore this dependence can be ignored when performing the integration over α, i.e., in terms of particle coordinates, ∂F0∕∂𝜀 is approximately independent of the gyro-angle α. Then the integration over α in Eq. (211) can be performed, yielding where again use has been made of the deﬁnition of the Bessel function.
In order to perform the remaining velocity integration in expression (212), we assume that F0 is a Maxwellian distribution given by
|
| (215) |
Again we will ignore the weak dependence of n0(X) and T(X) on v introduced by X = x + v × e∥∕Ω when transformed back to particle coordinates.  Since the velocity integration limit is to inﬁnite, this will deﬁnitely occur. However, F0 is exponentially decreasing with velocity, making those particles with velocity much larger than the thermal velocity negligibly few and thus can be neglected.)
Parallel integration Using Eq. (215), the expression in the square brackets of Eq. (212) is written as
where v∥ = v∥∕vt, v⊥ = v⊥∕vt. Using|
| (218) |
the integration over v∥ in expression (217) can be performed, yielding
|
| (219) |
Perpendicular integration Using (I veriﬁed this by using Sympy)
|
| (220) |
where I0(a) is the zeroth modiﬁed Bessel function of the ﬁrst kind, expression (219) is written
|
| (221) |
where b = k⊥2vt2∕Ω2 = k⊥2ρt2. Then the corresponding density (201) is written as
|
| (222) |
In Fourier space, the adiabatic term in expression (200) is written as
|
| (223) |
Plugging expression (222) and (223) into expression (191), the polarization density np is written as
Deﬁne|
| (225) |
then Eq. (224) is written as
|
| (226) |
Expression (226) agrees with the result given in Yang Chen’s notes. Note that the dependence on species mass enters the formula through the Larmor radius ρt in Γ0.
Γ0 deﬁned in Eq. (225) can be approximated by the Pade approximation as
|
| (227) |
The comparison between the exact value of Γ0 and the above Pade approximation is shown in Fig. 4.
Using the Pade approximation (227), the polarization density np in expression (226) can be written as
(Pade approximate is the “best” approximation of a function by a rational function of given order – under this technique, the approximant’s power series agrees with the power series of the function it is approximating.)In the long wavelength limit, k⊥ρ ≪ 1, expression (228) can be further approximated as
Then the corresponding term in the Poisson equation is written as where λD is the Debye length deﬁned by λD2 = T𝜀0∕(n0q2). For typical tokamak plasmas, the thermal ion gyroradius ρi is much larger than λD. Therefore the term in expression (230) for ions is much larger than the space charge term ∇2δΦ ≡∇⊥2δΦ + ∇∥2δΦ ≈∇⊥2δΦ in the Poisson equation. Therefore the space charge term can be neglected in the long wavelength limit.Equation (230) also shows that electron polarization density is smaller than the ion polarization density by a factor of ρe∕ρi ≈ 1∕60. Note that this conclusion is drawn in the long wavelength limit. For short wavelength, the electron polarization and ion polarization density can be of similar magnitude (to be discussed later).
The polarization density expression (229) is for the long wavelength limit, which partially neglects FLR eﬀect. Let us go back to the more general expression (228). The Poisson equation is written
|
| (231) |
Write δni = npi + δni′, where δnpi is the ion polarization density, then the above expression is written
|
| (232) |
Fourier transforming in space, the above equation is written
|
| (233) |
where pi is the Fourier transformation (in space) of the polarization density npi and similar meanings for δ, δi′, and δe. Expression (228) implies that pi is given by
|
| (234) |
Using this, equation (233) is written
|
| (235) |
Multiplying both sides by (1 + k⊥2ρi2)∕𝜀0, the above equation is written
|
| (236) |
Next, transforming the above equation back to the real space, we obtain
|
| (237) |
Neglecting the Debye shielding term, the above equation is written
|
| (238) |
which is the equation actually solved in many gyrokinetic codes, where λDi2 = 𝜀0Ti∕(qi2ni0).


--- layout: homepage title: Prasshanth Srinivasan ---
Hi! My name is Prasshanth Srinivasan, and I am a software engineer currently living in Philadelphia.
Resume: Link


Allows users to run QF-Test suites as part of the build step
Plugin Information |
|---|
View QF-Test on the plugin site for more information. |
This plugin enables QF-Test integration with Jenkins.
QF-Test is a cross-platform software tool for the GUI test automation specialized on Java and Web
applications.
For an in-depth look at the plugin and all of its available features, please have a look into the video tutorials (English / German) or visit the QF-Test manual.
Quick Installation Guide:
- Go to Jenkins → Manage Jenkins → Manage Plugins → Available
- Select the QF-Test Plugin and click on the 'Install' button
- Restart Jenkins
How to use the QF-Test Plugin:
- If you don't already have a Jenkins project for QF-Test, you might want to create one (usually a Freestyle project).
Configure the project:
- In the 'Advanced Project Options' section click on 'Advanced...'
- Select 'Use custom workspace' and enter the path to the folder containg the test-suites.
- In the 'Build' section click on 'Add build step' and select 'Run QF-Test'.
- In the left field enter the name of the test-suite or a folder with test-suites you want to run.
- In the right field you can enter additional command line arguments as described in the „Test execution“ section of the QF-Test manual.
- By using the 'Add' and 'Delete' buttons, you can specify multiple test-suites if necessary. \\\\
Configure reporting:
The next steps are used to process test results and archive QF-Test run-logs and HTML reports.
Store run-logs as artifacts
- In the 'Post-build Actions' section click on 'Add post-build action' and choose 'Archive the artifacts'.
- Under 'Files to archive' copy and paste this path: qftestJenkinsReports/$JOB_NAME/$BUILD_NUMBER/logs/*.q**
Publish HTML reports
- Add post-build action 'Publish HTML reports' .
- Click on 'Add' .
- In the HTML directory to archive copy and paste this path: qftestJenkinsReports/$JOB_NAME/$BUILD_NUMBER/html/
- Change the Index page from index.html to report.html .
- Check the box 'Keep past HTML reports', if you want to keep all HTML reports.
Process test results
- Add post-build action 'Publish JUnit test result' .
- In the 'Test report XMLs' textfield copy and paste this path: qftestJenkinsReports/$JOB_NAME/$BUILD_NUMBER/junit/report_junit.xml
- Click on 'Save'.
Troubleshooting
Always check the console output of your build, in case of problems.
It may also be helpful to add the command line argument '-dbg' to get additional debug information in the console output.
If that doesn't help you to solve the problem, please take a look at the QF-Test manual or contact the QFS support.
Attachments:
jenkinsBuildstep.png (image/png)
jenkinsPostBuildActions.png (image/png)
artifacts.jpg (image/jpeg)
artifacts.png (image/png)
htmlreports.png (image/png)
junit.png (image/png)


{% include shared/head.html %} {% include shared/header.html %}
{{ page.title }}
{{ content }}
{% include shared/footer.html %}


{{Multiple issues| {{unreferenced|date=February 2013}} {{Notability|date=October 2015}} }} {{Italic title}} {{Infobox prepared food | name = Frankfurter Rindswurst | image =Frankfurter-gref-voelsing-rindswurst-001.jpg | caption =Original Rindswurst | alternate_name = | country = Frankfurt, Germany | region = | creator = | course = Sausage | served = | main_ingredient = beef | variations = | calories = | other = }}
Frankfurter Rindswurst (German for “Frankfurt beef sausage”) is a sausage made of pure beef meat. It was introduced in 1894 by Frankfurt butcher Gref-Volsing to meet the demands of the growing Jewish population of the city and has since become one of its most famous delicacies. The sausage may be boiled, broiled, or grilled.
{{Beef}}
{{meat-stub}} {{germany-cuisine-stub}}


Enter your trip details to get started.
Total Flights
{{ tripcount }}
{{ days_since_last_trip }} days
since your last trip.
International
{{ internationalflights }}
{{ diffint }} more than
Domestic.
Domestic
{{ domesticflights }}
{{ last_dom_trip }}Last trip.
Last Flight
{{ lastsource }} to {{ lastdestination }}
{{ lastdate }} Last
trip date.
Most Travelled International
Destination
{{ mostvisiteddest }}
{{ mostvisiteddestcount }}
trips.
Most Travelled Domestic
Destination
{{ mostvisiteddomdest }}
{{ mostvisiteddomdestcount }} trips.
Lorem ipsum
5.284
7% more than last week.


ABOUT ME
My name is Ilker Bozcan. I am professional machine learning and computer vision engineer.
Currently, I am conducting my Ph.D. research on analyzing aerial images captured by drones. More specifically, I am working on object detection in challenging aerial images, and anomaly detection for aerial surveillance (finding suspucious objects, events, actions in a crowd).
I also design and develop machine learning-based solutions for my clients in my freetime, mostly for visual recognition. I like using my research and engineering skills for usefulness.
MY SERVICES
I help my clients to develop AI-based visual recognition systems for their services or products.
ML Development
Design, develop and optimize machine learning algorithms for different domains.
Object Detection
Identify object categories in images with the location of each object instance.
Semantic Segmentation
Label and predict objects at the pixel level, and segment image regions.
Data Classification
Classify data (image, audio, stock) into predefined categories.
Dataset Analysis
Analyze requirements of datasets and optimize data gathering process.
Research for Industry
Survey the literature for state-of-the-art methods to adapt the business.
MY PUBLICATIONS
CONTACT ME
Turing 0, Building 5341, Aabogade 34, 8200 Aarhus N, Denmark
+45 50 35 86 72
<EMAIL_ADDRESS>ilkerbozcan@hotmail.com