###############################################################################
"""run step3 of the OSSOS pipeline."""
import os
import argparse
import logging
import sys
from ossos import util
from ossos import storage
_RATE_MIN = 0.5
_RATE_MAX = 15.0
_ANGLE_CENTRE = 23.0
_ANGLE_WIDTH = 30.0
task = util.task()
dependency = 'step2'
def run(expnums,
ccd,
version,
rate_min,
rate_max,
angle,
width,
field=None,
prefix=None,
dry_run=False,
force=False):
"""run the actual step2 on the given exp/ccd combo"""
if args.dry_run:
args.force = True
# # setup logging
level = logging.CRITICAL
if args.debug:
level = logging.DEBUG
elif args.verbose:
level = logging.INFO
if not args.no_sort:
args.expnums.sort()
storage.DBIMAGES = args.dbimages
prefix = ""
task = util.task()
dependency = "step1"
logging.basicConfig(level=level, format="%(message)s")
ccds = [args.ccd]
if args.ccd is None:
ccds = range(0, 36)
for ccd in ccds:
message = storage.SUCCESS
try:
storage.set_logger(task, prefix, args.expnums[0], ccd, args.type, args.dry_run)
if not storage.get_status(dependency, prefix, args.expnums[0], version=args.type, ccd=ccd):
raise IOError("mkpsf not yet run for %s ccd%s, can't run align" % (
str(args.expnums), str(ccd).zfill(2)))
def main():
parser = argparse.ArgumentParser(
description='Run mopheader chunk of the OSSOS pipeline')
parser.add_argument('--ccd', '-c',
action='store',
type=int,
dest='ccd',
default=None,
help='which ccd to process, default is all')
parser.add_argument('--ignore-update-headers', action='store_true', dest='ignore_update_headers')
parser.add_argument("--dbimages",
action="store",
default="vos:OSSOS/dbimages",
help='vospace dbimages containerNode')
parser.add_argument("expnum",
type=int,
nargs='+',
help="expnum(s) to process")
parser.add_argument("--dry-run",
action="store_true",
help="DRY RUN, don't copy results to VOSpace, implies --force")
parser.add_argument("--fk", action="store_true", help="Run fk images")
parser.add_argument("--type", "-t", choices=['o', 'p', 's'],
help="which type of image: o-RAW, p-ELIXIR, s-SCRAMBLE", default='p')
parser.add_argument("--verbose", "-v",
action="store_true")
parser.add_argument("--force", default=False,
action="store_true")
parser.add_argument("--debug", "-d",
action="store_true")
args = parser.parse_args()
util.set_logger(args)
logging.info("started")
prefix = (args.fk and 'fk') or ''
task = util.task()
dependency = 'update_header'
storage.DBIMAGES = args.dbimages
if args.ccd is None:
ccdlist = range(0, 36)
else:
ccdlist = [args.ccd]
exit_code = 0
for expnum in args.expnum:
for ccd in ccdlist:
logging.info("Attempting to get status on header for {} {}".format(expnum, ccd))
storage.set_logger(task,
prefix, expnum, ccd, args.type, args.dry_run)
if storage.get_status(task, prefix, expnum, version=args.type, ccd=ccd) and not args.force:
logging.info("{} completed successfully for {} {} {} {}".format(task, prefix, expnum, args.type, ccd))
continue
message = 'success'
try:
logging.info("Building a header ")
if not storage.get_status(dependency, prefix, expnum, "p", 36) and not args.ignore_update_headers:
raise IOError("{} not yet run for {}".format(dependency, expnum))
mk_mopheader(expnum, ccd, args.type, args.dry_run, prefix=prefix)
except CalledProcessError as cpe:
message = str(cpe.output)
exit_code = message
except Exception as e:
message = str(e)
logging.info(message)
logging.error(message)
if not args.dry_run:
storage.set_status(task, prefix, expnum, version=args.type, ccd=ccd, status=message)
return exit_code
def main(task='step1'):
### Must be running as a script
parser = argparse.ArgumentParser(
description='Run step1jmp and step1matt on a given exposure.')
parser.add_argument("--ccd", "-c",
action="store",
default=None,
type=int,
dest="ccd")
parser.add_argument("--ignore", help="Try to run even in previous step failed.",
default=False,
action="store_true")
parser.add_argument("--fk", help="add the fk prefix on processing?",
default=False,
action='store_true')
parser.add_argument("--dbimages",
action="store",
default="vos:OSSOS/dbimages",
help='vospace dbimages containerNode')
parser.add_argument("--sex_thresh",
action="store",
type=float,
default=_SEX_THRESHOLD,
help="sExtractor detection threhold")
parser.add_argument("--wavelet_thresh",
type=float,
default=_WAVE_THRESHOLD,
help="Wavelet detection threhold")
parser.add_argument("expnum",
type=int,
nargs='+',
help="expnum(s) to process")
parser.add_argument("--version",
action='version',
version='%(prog)s 1.0')
parser.add_argument('--type', default='p',
choices=['o', 'p', 's'], help="which type of image")
parser.add_argument('--log', default=None, help="Write standard out to this file")
parser.add_argument("--verbose", "-v",
action="store_true")
parser.add_argument("--debug", '-d',
action='store_true')
parser.add_argument("--force", action="store_true")
parser.add_argument("--dry-run", action="store_true", help="Do a dry run, not changes to vospce, implies --force")
cmd_line = " ".join(sys.argv)
args = parser.parse_args()
util.set_logger(args)
logging.info("Starting {}".format(cmd_line))
storage.DBIMAGES = args.dbimages
prefix = (args.fk and 'fk') or ''
task = util.task()
dependency = "mkpsf"
version = args.type
exit_code = 0
for expnum in args.expnum:
if args.ccd is None:
if int(expnum) < 1785619:
# Last exposures with 36 CCD Megaprime
ccdlist = range(0,36)
else:
# First exposrues with 40 CCD Megaprime
ccdlist = range(0, 40)
else:
ccdlist = [args.ccd]
for ccd in ccdlist:
try:
message = storage.SUCCESS
if not (args.force or args.dry_run) and storage.get_status(task, prefix, expnum, version, ccd):
logging.critical("{} completed successfully for {}{}{}{:02d}".format(
task, prefix, expnum, version, ccd))
continue
if not storage.get_status(dependency, prefix, expnum, version, ccd) and not args.ignore:
raise IOError(35, "Cannot start {} as {} not yet completed for {}{}{}{:02d}".format(
task, dependency, prefix, expnum, version, ccd))
storage.set_logger(task, prefix, expnum, ccd, args.type, args.dry_run)
step1(expnum, ccd, prefix=prefix, version=version, dry_run=args.dry_run)
except Exception as ex:
message = str(ex)
logging.error(message)
if not args.dry_run:
storage.set_status(task, prefix, expnum, version, ccd, status=message)
logging.info(message)
return exit_code
def main():
parser = argparse.ArgumentParser(
description='Run step1jmp and step1matt on a given exposure.')
parser.add_argument("--ccd", "-c",
action="store",
default=None,
type=int,
dest="ccd")
parser.add_argument("--fk", help="add the fk prefix on processing?",
default=False,
action='store_true')
parser.add_argument("--dbimages",
action="store",
default="vos:OSSOS/dbimages",
help='vospace dbimages containerNode')
parser.add_argument("--field",
action="store",
default=None,
help="Name of the field being combined")
parser.add_argument("expnum",
type=int,
help="expnum to process")
parser.add_argument("--measure3",
action="store",
help="VOSpace location for measure3 files",
default=MEASURE3)
parser.add_argument('--type', default='p', choices=['o', 'p', 's'], help="which type of image")
parser.add_argument("--verbose", "-v",
action="store_true")
parser.add_argument("--debug", '-d',
action='store_true')
parser.add_argument("--force", '-f', action='store_true')
parser.add_argument("--dry-run", action="store_true", help="Don't push back to VOSpace, implies --force")
args = parser.parse_args()
level = logging.CRITICAL
if args.debug:
level = logging.DEBUG
elif args.verbose:
level = logging.INFO
logging.basicConfig(level=level, format="%(message)s")
storage.DBIMAGES = args.dbimages
storage.MEASURE3 = args.measure3
prefix = (args.fk and 'fk') or ''
task = util.task()
dependency = 'step3'
ccd_list = (args.ccd is None and range(0, 36)) or [args.ccd]
exit_code = 0
for ccd in ccd_list:
# storage.set_logger(task, prefix, args.expnum, ccd, args.type, args.dry_run)
try:
# if not storage.get_status(dependency, prefix, args.expnum, version=args.type, ccd=ccd) and not args.dry_run:
# message = storage.get_status(dependency, prefix, args.expnum, "p", ccd, return_message=True)
# raise IOError(35, message)
# if storage.get_status(task, prefix, args.expnum, version=args.type, ccd=ccd) and not args.force:
# continue
message = combine(args.expnum,
ccd,
prefix=prefix,
file_type=args.type,
field=args.field,
measure3=args.measure3,
dry_run=args.dry_run)
except CalledProcessError as cpe:
message = str(cpe)
exit_code = message
except Exception as e:
message = str(e)
exit_code = message
print message
logging.info(message)
#if not args.dry_run:
# storage.set_status(task, prefix, args.expnum, version=args.type, ccd=ccd, status=message)
return exit_code
def main():
"""Run the script."""
parser = argparse.ArgumentParser()
parser.add_argument('--ccd',
action='store',
type=int,
default=None,
help='which ccd to process')
parser.add_argument("--dbimages",
action="store",
default="vos:OSSOS/dbimages",
help='vospace dbimages containerNode')
parser.add_argument("expnums",
type=int,
nargs=3,
help="expnums to scramble")
parser.add_argument("--nosort",
action='store_true',
default=False,
help="do not sort before processing")
parser.add_argument("--type",
action='store',
default='p',
choices=['p', 'o'],
help='which type of image')
parser.add_argument("--verbose", "-v",
action="store_true")
parser.add_argument("--debug", '-d',
action='store_true')
parser.add_argument("--dry-run", action="store_true", help="Do not copy back to VOSpace, implies --force")
parser.add_argument("--force", action='store_true')
args = parser.parse_args()
prefix = ""
task = util.task()
dependency = "update_header"
storage.DBIMAGES = args.dbimages
## setup logging
level = logging.CRITICAL
if args.debug:
level = logging.DEBUG
elif args.verbose:
level = logging.INFO
logging.basicConfig(level=level, format="%(message)s")
logging.getLogger('vos').setLevel(level)
logging.getLogger('vos').addHandler(logging.StreamHandler())
if not args.nosort:
args.expnums.sort()
ccds = [args.ccd]
exit_status = 0
if args.ccd is None:
ccds = range(0, 36)
for ccd in ccds:
storage.set_logger(task, prefix, args.expnums[0], ccd, args.type, args.dry_run)
expnums = args.expnums
if not (args.force or args.dry_run) and storage.get_status(task, prefix, expnums[0], version='s', ccd=ccd):
continue
message = storage.SUCCESS
try:
scramble(expnums=expnums, ccd=ccd, version='p', dry_run=args.dry_run)
except Exception as e:
logging.error(e)
message = str(e)
exit_status = message
if not args.dry_run:
storage.set_status(task, prefix, expnums[0], version='s', ccd=ccd, status=message)
return exit_status
def main():
"""Do the script."""
parser = argparse.ArgumentParser(description='replace image header')
parser.add_argument('--extname', help='name of extension to in header')
parser.add_argument('expnum', type=str, help='exposure to update')
parser.add_argument('-r',
'--replace',
action='store_true',
help='store modified image back to VOSpace?')
parser.add_argument('-v', '--verbose', action='store_true')
parser.add_argument('--debug', action='store_true')
parser.add_argument('--force',
action='store_true',
help="Re-run even if previous success recorded")
parser.add_argument('--dbimages',
help="VOSpace DATA storage area.",
default="vos:OSSOS/dbimages")
args = parser.parse_args()
task = util.task()
dependency = 'preproc'
prefix = ""
storage.DBIMAGES = args.dbimages
level = logging.CRITICAL
message_format = "%(message)s"
if args.verbose:
level = logging.INFO
if args.debug:
level = logging.DEBUG
message_format = "%(module)s %(funcName)s %(lineno)s %(message)s"
logging.basicConfig(level=level, format=message_format)
storage.set_logger(task, prefix, args.expnum, None, None, False)
message = storage.SUCCESS
expnum = args.expnum
exit_status = 0
try:
# skip if already succeeded and not in force mode
if storage.get_status(task, prefix, expnum, "p",
36) and not args.force:
logging.info("Already updated, skipping")
sys.exit(0)
image_hdulist = storage.get_image(args.expnum, return_file=False)
ast_hdulist = storage.get_astheader(expnum, ccd=None)
run_update_header(image_hdulist, ast_hdulist)
image_filename = os.path.basename(storage.get_uri(expnum))
image_hdulist.writeto(image_filename)
if args.replace:
dest = storage.dbimages_uri(expnum)
storage.copy(image_filename, dest)
storage.set_status('update_header', "", expnum, 'p', 36, message)
except Exception as e:
message = str(e)
if args.replace:
storage.set_status(task, prefix, expnum, 'p', 36, message)
exit_status = message
logging.error(message)
return exit_status
def main(argv):
"""
@param argv: an array of arguments to be parsed, normally sys.argv
@return: None
"""
parser = argparse.ArgumentParser()
parser.add_argument('--ccd',
action='store',
type=int,
default=None,
help='which ccd to process')
parser.add_argument("--dbimages",
action="store",
default="vos:OSSOS/dbimages",
help='vospace dbimages containerNode')
parser.add_argument("expnums",
type=int,
nargs=3,
help="expnum(s) to process")
parser.add_argument("--type",
action='store',
default='s',
choices=['s', 'p', 'o'],
help='which type of image')
parser.add_argument('--no-sort',
action='store_true',
default=False,
help='do not sort exposure list by expnum before processing')
parser.add_argument("--verbose", "-v",
action="store_true")
parser.add_argument("--debug", '-d',
action='store_true')
parser.add_argument("--number", "-n", type=int, help="Number of KBOs to plant into images.", default=10)
parser.add_argument("--mmin", type=float, help="Minimum magnitude value to add source with.", default=21.0)
parser.add_argument("--mmax", type=float, help="Maximum magnitude value to add source with.", default=25.5)
parser.add_argument("--rmin", default=0.5,
type=float, help="minimum motion rate")
parser.add_argument("--rmax", default=15,
type=float, help="maximum motion rate")
parser.add_argument("--width", default=30,
type=float, help="angle opening")
parser.add_argument("--ang", default=20,
type=float, help="angle of motion, 0 is West")
parser.add_argument("--force", action="store_true")
parser.add_argument("--dry-run", action="store_true")
args = parser.parse_args(argv)
# # setup logging
level = logging.CRITICAL
if args.debug:
level = logging.DEBUG
elif args.verbose:
level = logging.INFO
if not args.no_sort:
args.expnums.sort()
storage.DBIMAGES = args.dbimages
logging.basicConfig(level=level, format="%(message)s")
task = util.task()
prefix = ""
dependency = 'mkpsf'
ccds = [args.ccd]
if args.ccd is None:
ccds = range(0, 36)
exit_code = 0
for ccd in ccds:
message = storage.SUCCESS
try:
storage.set_logger(task, prefix, args.expnums[0], ccd, args.type, args.dry_run)
if not storage.get_status(dependency, prefix, args.expnums[0], version='s', ccd=ccd):
raise IOError("{} not yet run for {} {} {}".format(dependency, args.expnums, args.type, ccd))
if storage.get_status(task, prefix, args.expnums[0], version=args.type, ccd=ccd) and not args.force:
logging.info("{} previously completed successfully for {}{}{:02d}".format(task,
args.expnums[0],
args.type,
ccd))
continue
plant(args.expnums,
ccd,
args.rmin, args.rmax, args.ang, args.width,
number=args.number, mmin=args.mmin, mmax=args.mmax,
version=args.type,
dry_run=args.dry_run)
except CalledProcessError as cpe:
message = str(cpe)
exit_code = message
except Exception as e:
message = str(e)
logging.critical(message)
if not args.dry_run:
storage.set_status(task, prefix, args.expnums[0], version=args.type, ccd=ccd, status=message)
return exit_code
def main():
"""Do the script."""
parser = argparse.ArgumentParser(
description='replace image header')
parser.add_argument('--extname',
help='name of extension to in header')
parser.add_argument('expnum', type=str,
help='exposure to update')
parser.add_argument('-r', '--replace',
action='store_true',
help='store modified image back to VOSpace?')
parser.add_argument('-v', '--verbose', action='store_true')
parser.add_argument('--debug', action='store_true')
parser.add_argument('--force', action='store_true', help="Re-run even if previous success recorded")
parser.add_argument('--dbimages', help="VOSpace DATA storage area.", default="vos:OSSOS/dbimages")
args = parser.parse_args()
task = util.task()
dependency = 'preproc'
prefix = ""
storage.DBIMAGES = args.dbimages
level = logging.CRITICAL
message_format = "%(message)s"
if args.verbose:
level = logging.INFO
if args.debug:
level = logging.DEBUG
message_format = "%(module)s %(funcName)s %(lineno)s %(message)s"
logging.basicConfig(level=level, format=message_format)
storage.set_logger(task, prefix, args.expnum, None, None, False)
message = storage.SUCCESS
expnum = args.expnum
exit_status = 0
try:
# skip if already succeeded and not in force mode
if storage.get_status(task, prefix, expnum, "p", 36) and not args.force:
logging.info("Already updated, skipping")
sys.exit(0)
image_hdulist = storage.get_image(args.expnum, return_file=False)
ast_hdulist = storage.get_astheader(expnum, ccd=None)
run_update_header(image_hdulist, ast_hdulist)
image_filename = os.path.basename(storage.get_uri(expnum))
image_hdulist.writeto(image_filename)
if args.replace:
dest = storage.dbimages_uri(expnum)
storage.copy(image_filename, dest)
storage.set_status('update_header', "", expnum, 'p', 36, message)
except Exception as e:
message = str(e)
if args.replace:
storage.set_status(task, prefix, expnum, 'p', 36, message)
exit_status = message
logging.error(message)
return exit_status
def main():
### Must be running as a script
parser = argparse.ArgumentParser(
description='Run step2jmp and step2matt on a given exposure.')
parser.add_argument("--ccd", "-c",
action="store",
default=None,
type=int,
dest="ccd")
parser.add_argument("--fk", action="store_true", default=False, help="Do fakes?")
parser.add_argument("--dbimages",
action="store",
default="vos:OSSOS/dbimages",
help='vospace dbimages containerNode')
parser.add_argument("expnums",
type=int,
nargs=3,
help="3 expnums to process")
parser.add_argument("--version",
action='version',
version='%(prog)s 1.0')
parser.add_argument('-t', '--type',
help='which type of image to process',
choices=['s', 'p', 'o'],
default='p')
parser.add_argument('--no-sort',
help='preserve input exposure order',
action='store_true')
parser.add_argument("--verbose", "-v",
action="store_true")
parser.add_argument("--default", default="WCS",
choices=['WCS', 'JMP'],
help="Which shift should be used if they dis-agree?")
parser.add_argument("--debug",
action="store_true")
parser.add_argument("--dry-run", action="store_true", help="run without pushing back to VOSpace, implies --force")
parser.add_argument("--force", action="store_true")
args = parser.parse_args()
if args.verbose:
logging.basicConfig(level=logging.INFO, format="%(message)s")
if args.debug:
logging.basicConfig(level=logging.DEBUG, format="%(message)s")
storage.DBIMAGES = args.dbimages
if args.ccd is None:
ccd_list = range(0, 36)
else:
ccd_list = [args.ccd]
prefix = (args.fk and "fk") or ""
if not args.no_sort:
args.expnums.sort()
task = util.task()
dependency = "step1"
expnums = args.expnums
version = args.type
exit_status = 0
for ccd in ccd_list:
storage.set_logger(os.path.splitext(os.path.basename(sys.argv[0]))[0],
prefix, args.expnums[0], ccd, args.type, args.dry_run)
try:
message = storage.SUCCESS
# Check if dependent task has finished for each of the input exposure ids.
for expnum in expnums:
if not storage.get_status(dependency, prefix, expnum, version=version, ccd=ccd):
raise IOError(35, "Cannot start {} as {} not yet completed for {}{}{}{:02d}".format(
task, dependency, prefix, expnum, args.type, ccd))
# Check if we need to run this step on the current frame.
if not (args.force or args.dry_run) and storage.get_status(task, prefix, args.expnums[0], version=version,
ccd=ccd):
logging.info("{} completed successfully for {}{}{}{:02d}".format(
task, prefix, expnums[0], version, ccd))
continue
logging.info("Executing {} on {} {} {} {}".format(
task, prefix, args.expnums, args.type, ccd))
step2(args.expnums, ccd, version=version, prefix=prefix, dry_run=args.dry_run, default=args.default)
logging.info(message)
except CalledProcessError as cpe:
message = str(cpe)
logging.error(message)
exit_status = message
except Exception as e:
message = str(e)
logging.error(message)
exit_status = message
if not args.dry_run:
storage.set_status(task, prefix, args.expnums[0], version=version, ccd=ccd, status=message)
return exit_status
def main(task='mkpsf'):
parser = argparse.ArgumentParser(
description='Run makepsf chunk of the OSSOS pipeline')
parser.add_argument('--ccd', '-c',
action='store',
type=int,
dest='ccd',
default=None,
help='which ccd to process, default is all')
parser.add_argument("--dbimages",
action="store",
default="vos:OSSOS/dbimages",
help='vospace dbimages containerNode')
parser.add_argument("expnum",
type=int,
nargs='+',
help="expnum(s) to process")
parser.add_argument("--dry-run",
action="store_true",
help="DRY RUN, don't copy results to VOSpace, implies --force")
parser.add_argument("--fk", action="store_true", help="Run fk images")
parser.add_argument("--type", "-t", choices=['o', 'p', 's'],
help="which type of image: o-RAW, p-ELIXIR, s-SCRAMBLE", default='p')
parser.add_argument("--verbose", "-v",
action="store_true")
parser.add_argument("--force", default=False,
action="store_true")
parser.add_argument("--debug", "-d",
action="store_true")
args = parser.parse_args()
util.set_logger(args)
prefix = (args.fk and 'fk') or ''
task = util.task()
dependency = 'mk_mopheader'
storage.DBIMAGES = args.dbimages
exit_code = 0
for expnum in args.expnum:
if args.ccd is None:
if int(expnum) < 1785619:
# Last exposures with 36 CCD Megaprime
ccdlist = range(0,36)
else:
# First exposrues with 40 CCD Megaprime
ccdlist = range(0, 40)
else:
ccdlist = [args.ccd]
for ccd in ccdlist:
if storage.get_status(task, prefix, expnum, version=args.type, ccd=ccd) and not args.force:
logging.info("{} completed successfully for {} {} {} {}".format(task, prefix, expnum, args.type, ccd))
continue
storage.set_logger(task,
prefix, expnum, ccd, args.type, args.dry_run)
message = 'success'
try:
if not storage.get_status(dependency, prefix, expnum, "p", ccd=ccd):
raise IOError("{} not yet run for {}".format(dependency, expnum))
mkpsf(expnum, ccd, args.type, args.dry_run, prefix=prefix)
if args.dry_run:
continue
storage.set_status('fwhm', prefix, expnum, version=args.type, ccd=ccd, status=str(storage.get_fwhm(
expnum, ccd, version=args.type)))
storage.set_status('zeropoint', prefix, expnum, version=args.type, ccd=ccd,
status=str(storage.get_zeropoint(
expnum, ccd, version=args.type)))
except Exception as e:
message = str(e)
logging.error(message)
if not args.dry_run:
storage.set_status(task, prefix, expnum, version=args.type, ccd=ccd, status=message)
return exit_code
def main():
parser = argparse.ArgumentParser()
parser.add_argument('field')
parser.add_argument('ccd')
parser.add_argument('--expnum', default=None, help="Which exposure is the lead for this astrom file?")
parser.add_argument('--astrom-filename', default=None, help="Give the astrom file directly instead of looking-up "
"using the field/ccd naming scheme.")
parser.add_argument('--reals', action='store_true', default=False)
parser.add_argument('--type', choices=['o', 'p', 's'], help="Which type of image.", default='s')
parser.add_argument('--measure3', default='vos:OSSOS/measure3/2013B-L_redo/')
parser.add_argument('--dbimages', default=None)
parser.add_argument('--dry-run', action='store_true', default=False)
parser.add_argument('--force', action='store_true', default=False)
parser.add_argument('--object-planted', default=OBJECT_PLANTED,
help="Name of file contains list of planted objects.")
parser.add_argument('--bright-limit', default=BRIGHT_LIMIT,
help="Sources brighter than this limit {} are used to diagnose planting issues.".format(
BRIGHT_LIMIT))
parser.add_argument('--minimum-bright-detections', default=MINIMUM_BRIGHT_DETECTIONS,
help="required number of detections with mag brighter than bright-limit.")
parser.add_argument('--minimum-bright-fraction', default=MINIMUM_BRIGHT_FRACTION,
help="minimum fraction of objects above bright limit that should be found.")
args = parser.parse_args()
logging.basicConfig(level=logging.CRITICAL)
prefix = 'fk'
ext = args.reals and 'reals' or 'cands'
task = util.task()
storage.MEASURE3 = args.measure3
if args.dbimages is not None:
storage.DBIMAGES = args.dbimages
astrom.DATASET_ROOT = args.dbimages
astrom_uri = storage.get_cands_uri(args.field,
ccd=args.ccd,
version=args.type,
prefix=prefix,
ext="measure3.{}.astrom".format(ext))
if args.astrom_filename is None:
astrom_filename = os.path.basename(astrom_uri)
else:
astrom_filename = args.astrom_filename
if not os.access(astrom_filename, os.F_OK):
astrom_filename = os.path.dirname(astrom_uri) + "/" + astrom_filename
# Load the list of astrometric observations that will be looked at.
fk_candidate_observations = astrom.parse(astrom_filename)
if args.expnum is None:
expnum = fk_candidate_observations.observations[0].expnum
else:
expnum = args.expnum
storage.set_logger(os.path.splitext(os.path.basename(sys.argv[0]))[0], prefix, expnum, "", ext, args.dry_run)
match_filename = os.path.splitext(os.path.basename(astrom_filename))[0] + '.match'
exit_status = 0
status = storage.SUCCESS
try:
if (not storage.get_status(task, prefix, expnum=expnum, version='', ccd=args.ccd)) or args.force:
logging.info(("Comparing planted and measured magnitudes "
"for sources in {} and {}\n".format(args.object_planted, astrom_filename)))
message = match_planted(fk_candidate_observations,
match_filename=match_filename,
object_planted=args.object_planted,
bright_limit=args.bright_limit,
minimum_bright_detections=args.minimum_bright_detections,
bright_fraction=args.minimum_bright_fraction)
match_uri = storage.get_cands_uri(args.field,
ccd=args.ccd,
version=args.type,
prefix=prefix,
ext="measure3.{}.match".format(ext), block=args.field)
if not args.dry_run:
storage.copy(match_filename, match_uri)
uri = os.path.dirname(astrom_uri)
keys = [storage.tag_uri(os.path.basename(astrom_uri))]
values = [message]
storage.set_tags_on_uri(uri, keys, values)
except Exception as err:
sys.stderr.write(str(err))
status = str(err)
exit_status = err.message
if not args.dry_run:
storage.set_status(task, prefix, expnum, version='', ccd=args.ccd, status=status)
return exit_status
