def check_input_options(args):
"""
Perform pre-flight checks on input options
returns ok(True/False), message
"""
if args.bundlesize % args.nsubbundles != 0:
msg = 'bundlesize ({}) must be evenly divisible by nsubbundles ({})'.format(
args.bundlesize, args.nsubbundles)
return False, msg
if args.nspec % args.bundlesize != 0:
msg = 'nspec ({}) must be evenly divisible by bundlesize ({})'.format(
args.nspec, args.bundlesize)
return False, msg
if args.specmin % args.bundlesize != 0:
msg = 'specmin ({}) must begin at a bundle boundary'.format(
args.specmin)
return False, msg
if args.gpu:
try:
import cupy as cp
except ImportError:
return False, 'cannot import module cupy'
if not cp.is_available():
return False, 'gpu is not available'
return True, 'OK'
import numpy as np
from gpu_specter.io import read_psf
from gpu_specter.extract.cpu import evalcoeffs
try:
import specter.psf
specter_available = True
except ImportError:
specter_available = False
try:
import cupy as cp
from numba import cuda
from gpu_specter.extract.gpu import evalcoeffs as gpu_evalcoeffs
gpu_available = cp.is_available()
except ImportError:
gpu_available = False
class TestPSFCoeff(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.psffile = pkg_resources.resource_filename(
'gpu_specter', 'test/data/psf-r0-00051060.fits')
cls.psfdata = read_psf(cls.psffile)
@classmethod
def tearDownClass(cls):
pass
cuda_installed = cuda.is_available()
except Exception:
cuda_installed = False
if cuda_installed:
# Infer if GPU is P100 or V100 or other
if "P100" in str(cuda.gpus[0]._device.name):
cuda_gpu_model = "P100"
elif "V100" in str(cuda.gpus[0]._device.name):
cuda_gpu_model = "V100"
else:
cuda_gpu_model = "other"
try:
import cupy
cupy_installed = cupy.is_available()
cupy_major_version = int(cupy.__version__[0])
except (ImportError, AssertionError):
cupy_installed = False
cupy_major_version = None
# -----------------------------------------------------
# CUDA grid utilities
# -----------------------------------------------------
def cuda_tpb_bpg_1d(x, TPB=256):
"""
Get the needed blocks per grid for a 1D CUDA grid.
Parameters :
"""
Core scaffolding for divide and conquer extraction algorithm
"""
import sys
import time
import numpy as np
try:
import numba.cuda
numba.cuda.is_available()
import cupy as cp
import cupy.prof
cp.is_available()
except ImportError:
pass
from gpu_specter.util import get_logger
from gpu_specter.util import get_array_module
from gpu_specter.util import Timer
from gpu_specter.util import gather_ndarray
class Patch(object):
def __init__(self, ispec, iwave, bspecmin, nspectra_per_patch, nwavestep,
wavepad, nwave, bundlesize, ndiag):
"""Convenience data wrapper for divide and conquer extraction patches
Args:
ispec: starting spectrum index
import unittest
import numpy as np
try:
import cupy as cp
cupy_available = cp.is_available()
except ImportError:
cupy_available = False
class TestPolynomial(unittest.TestCase):
@classmethod
def setUpClass(cls):
pass
@classmethod
def tearDownClass(cls):
pass
def setUp(self):
pass
def tearDown(self):
pass
def test_basics(self):
pass
@unittest.skipIf(not cupy_available, 'cupy not available')
def test_gpu_hermevander(self):
from gpu_specter.polynomial import hermevander
