def run_tests(use_interpolants, nitems=test_interpolants.default_nitems):
    """Run the tests for the specified interpolants."""

    import sys
    # Import the Sersic galaxy sample module
    try:
        import galaxy_sample
    except ImportError:
        import sys
        sys.path.append('../external/test_sersic_highn')
        import galaxy_sample

    # Get the COSMOS galaxy sample parameters
    ns_cosmos, hlrs_cosmos, gobss_cosmos = galaxy_sample.get()
    # Only use the first nitems galaxies in these lists, starting at test_interpolants.first_index
    istart = test_interpolants.default_first_index
    iend = istart + nitems
    ns_cosmos = ns_cosmos[istart: iend]
    hlrs_cosmos = hlrs_cosmos[istart: iend]
    gobss_cosmos = gobss_cosmos[istart: iend]

    # Draw a whole load of images of Sersic profiles at random orientations using these params
    sersic_images = draw_sersic_images(
        ns_cosmos, hlrs_cosmos, gobss_cosmos, random_seed=test_interpolants.rseed, nmin=0.3,
        nmax=4.2, image_size=SERSIC_IMAGE_SIZE, pixel_scale=test_interpolants.pixel_scale)

    # Calculate the reference results for g1obs, g2obs and sigma for these reference images
    g1_list = []
    g2_list = []
    sigma_list = []
    print "Calculating reference g1, g2 & sigma for "+str(len(sersic_images))+" Sersic images"
    for sersic_image in sersic_images:
        shape = test_interpolants.CatchAdaptiveMomErrors(sersic_image)
        if isinstance(shape, float):
            g1_list.append(-10)
            g2_list.append(-10)
            sigma_list.append(-10)
        elif isinstance(shape, galsim.hsm.ShapeData):
            g1_list.append(shape.observed_shape.g1)
            g2_list.append(shape.observed_shape.g2)
            sigma_list.append(shape.moments_sigma)
        else:
            raise TypeError("Unexpected output from test_interpolants.CatchAdaptiveMomErrors().")
    g1_list = np.asarray(g1_list)
    g2_list = np.asarray(g2_list)
    sigma_list = np.asarray(sigma_list)

    # Then start the interpolant tests...
    # Define a dict storing PSFs to iterate over along with the appropriate test pixel scale and
    # filename
    psf_dict = {
        "delta" : (
            galsim.Gaussian(1.e-8), test_interpolants.pixel_scale, DELTA_FILENAME),
        "original" : (
            None, test_interpolants.pixel_scale, ORIGINAL_FILENAME),
    }
    print''
    # Then we start the grand loop producing output in a similar fashion to test_interpolants.py
    for image_type in ("delta", "original"):
 
        # Get the correct PSF and test image pixel scale
        psf = psf_dict[image_type][0]
        dx_test = psf_dict[image_type][1]
        outfile = open(psf_dict[image_type][2], 'wb')
        print "Writing test results to "+str(outfile)
        for padding in test_interpolants.padding_list:

            print "Using padding = "+str(padding)
            for interpolant in use_interpolants:

                print "Using interpolant: "+str(interpolant)
                print 'Running Angle tests'
                for angle in test_interpolants.angle_list: # Possible rotation angles

                    sys.stdout.write('.')
                    sys.stdout.flush()
                    dataXint = calculate_interpolated_image_g1g2sigma(
                        sersic_images, psf=psf, dx_input=test_interpolants.pixel_scale,
                        dx_test=dx_test, shear=None, magnification=None, angle=angle*galsim.degrees,
                        shift=None, x_interpolant=interpolant, padding=padding,
                        image_type=image_type)
                    test_interpolants.print_results(
                        outfile, g1_list, g2_list, sigma_list, dataXint)
                    dataKint = calculate_interpolated_image_g1g2sigma(
                        sersic_images, psf=psf, dx_input=test_interpolants.pixel_scale,
                        dx_test=dx_test, shear=None, magnification=None, angle=angle*galsim.degrees,
                        shift=None, k_interpolant=interpolant, padding=padding,
                        image_type=image_type)
                    test_interpolants.print_results(
                        outfile, g1_list, g2_list, sigma_list, dataKint)
                sys.stdout.write('\n')
 
                print 'Running Shear/Magnification tests'
                for (g1, g2, mag) in test_interpolants.shear_and_magnification_list:

                    sys.stdout.write('.')
                    sys.stdout.flush()
                    dataXint = calculate_interpolated_image_g1g2sigma(
                        sersic_images, psf=psf, dx_input=test_interpolants.pixel_scale,
                        dx_test=dx_test, shear=(g1, g2), magnification=mag, angle=None,
                        shift=None, x_interpolant=interpolant, padding=padding,
                        image_type=image_type)
                    test_interpolants.print_results(
                        outfile, g1_list, g2_list, sigma_list, dataXint)
                    dataKint = calculate_interpolated_image_g1g2sigma(
                        sersic_images, psf=psf, dx_input=test_interpolants.pixel_scale,
                        dx_test=dx_test, shear=(g1, g2), magnification=mag, angle=None,
                        shift=None, k_interpolant=interpolant, padding=padding,
                        image_type=image_type)
                    test_interpolants.print_results(
                        outfile, g1_list, g2_list, sigma_list, dataKint)
                sys.stdout.write('\n')

                print 'Running Shift tests'
                for shift in test_interpolants.shift_list:

                    sys.stdout.write('.')
                    sys.stdout.flush()
                    dataXint = calculate_interpolated_image_g1g2sigma(
                        sersic_images, psf=psf, dx_input=test_interpolants.pixel_scale,
                        dx_test=dx_test, shear=None, magnification=None, angle=None,
                        shift=shift, x_interpolant=interpolant, padding=padding,
                        image_type=image_type)
                    test_interpolants.print_results(
                        outfile, g1_list, g2_list, sigma_list, dataXint)
                    dataKint = calculate_interpolated_image_g1g2sigma(
                        sersic_images, psf=psf, dx_input=test_interpolants.pixel_scale,
                        dx_test=dx_test, shear=None, magnification=None, angle=None,
                        shift=shift, k_interpolant=interpolant, padding=padding,
                        image_type=image_type)
                    test_interpolants.print_results(
                        outfile, g1_list, g2_list, sigma_list, dataKint)
                sys.stdout.write('\n')

                print ''

        print "Finished tests for image_type: "+str(image_type) 
        print ""
        outfile.close()
Exemple #2
0
def run_tests(use_interpolants, nitems=test_interpolants.default_nitems):
    """Run the tests for the specified interpolants."""

    import sys
    # Import the Sersic galaxy sample module
    try:
        import galaxy_sample
    except ImportError:
        import sys
        sys.path.append('../external/test_sersic_highn')
        import galaxy_sample

    # Get the COSMOS galaxy sample parameters
    ns_cosmos, hlrs_cosmos, gobss_cosmos = galaxy_sample.get()
    # Only use the first nitems galaxies in these lists, starting at test_interpolants.first_index
    istart = test_interpolants.default_first_index
    iend = istart + nitems
    ns_cosmos = ns_cosmos[istart:iend]
    hlrs_cosmos = hlrs_cosmos[istart:iend]
    gobss_cosmos = gobss_cosmos[istart:iend]

    # Draw a whole load of images of Sersic profiles at random orientations using these params
    sersic_images = draw_sersic_images(
        ns_cosmos,
        hlrs_cosmos,
        gobss_cosmos,
        random_seed=test_interpolants.rseed,
        nmin=0.3,
        nmax=4.2,
        image_size=SERSIC_IMAGE_SIZE,
        pixel_scale=test_interpolants.pixel_scale)

    # Calculate the reference results for g1obs, g2obs and sigma for these reference images
    g1_list = []
    g2_list = []
    sigma_list = []
    print "Calculating reference g1, g2 & sigma for " + str(
        len(sersic_images)) + " Sersic images"
    for sersic_image in sersic_images:
        shape = test_interpolants.CatchAdaptiveMomErrors(sersic_image)
        if isinstance(shape, float):
            g1_list.append(-10)
            g2_list.append(-10)
            sigma_list.append(-10)
        elif isinstance(shape, galsim.hsm.ShapeData):
            g1_list.append(shape.observed_shape.g1)
            g2_list.append(shape.observed_shape.g2)
            sigma_list.append(shape.moments_sigma)
        else:
            raise TypeError(
                "Unexpected output from test_interpolants.CatchAdaptiveMomErrors()."
            )
    g1_list = np.asarray(g1_list)
    g2_list = np.asarray(g2_list)
    sigma_list = np.asarray(sigma_list)

    # Then start the interpolant tests...
    # Define a dict storing PSFs to iterate over along with the appropriate test pixel scale and
    # filename
    psf_dict = {
        "delta": (galsim.Gaussian(1.e-8), test_interpolants.pixel_scale,
                  DELTA_FILENAME),
        "original": (None, test_interpolants.pixel_scale, ORIGINAL_FILENAME),
    }
    print ''
    # Then we start the grand loop producing output in a similar fashion to test_interpolants.py
    for image_type in ("delta", "original"):

        # Get the correct PSF and test image pixel scale
        psf = psf_dict[image_type][0]
        dx_test = psf_dict[image_type][1]
        outfile = open(psf_dict[image_type][2], 'wb')
        print "Writing test results to " + str(outfile)
        for padding in test_interpolants.padding_list:

            print "Using padding = " + str(padding)
            for interpolant in use_interpolants:

                print "Using interpolant: " + str(interpolant)
                print 'Running Angle tests'
                for angle in test_interpolants.angle_list:  # Possible rotation angles

                    sys.stdout.write('.')
                    sys.stdout.flush()
                    dataXint = calculate_interpolated_image_g1g2sigma(
                        sersic_images,
                        psf=psf,
                        dx_input=test_interpolants.pixel_scale,
                        dx_test=dx_test,
                        shear=None,
                        magnification=None,
                        angle=angle * galsim.degrees,
                        shift=None,
                        x_interpolant=interpolant,
                        padding=padding,
                        image_type=image_type)
                    test_interpolants.print_results(outfile, g1_list, g2_list,
                                                    sigma_list, dataXint)
                    dataKint = calculate_interpolated_image_g1g2sigma(
                        sersic_images,
                        psf=psf,
                        dx_input=test_interpolants.pixel_scale,
                        dx_test=dx_test,
                        shear=None,
                        magnification=None,
                        angle=angle * galsim.degrees,
                        shift=None,
                        k_interpolant=interpolant,
                        padding=padding,
                        image_type=image_type)
                    test_interpolants.print_results(outfile, g1_list, g2_list,
                                                    sigma_list, dataKint)
                sys.stdout.write('\n')

                print 'Running Shear/Magnification tests'
                for (g1, g2,
                     mag) in test_interpolants.shear_and_magnification_list:

                    sys.stdout.write('.')
                    sys.stdout.flush()
                    dataXint = calculate_interpolated_image_g1g2sigma(
                        sersic_images,
                        psf=psf,
                        dx_input=test_interpolants.pixel_scale,
                        dx_test=dx_test,
                        shear=(g1, g2),
                        magnification=mag,
                        angle=None,
                        shift=None,
                        x_interpolant=interpolant,
                        padding=padding,
                        image_type=image_type)
                    test_interpolants.print_results(outfile, g1_list, g2_list,
                                                    sigma_list, dataXint)
                    dataKint = calculate_interpolated_image_g1g2sigma(
                        sersic_images,
                        psf=psf,
                        dx_input=test_interpolants.pixel_scale,
                        dx_test=dx_test,
                        shear=(g1, g2),
                        magnification=mag,
                        angle=None,
                        shift=None,
                        k_interpolant=interpolant,
                        padding=padding,
                        image_type=image_type)
                    test_interpolants.print_results(outfile, g1_list, g2_list,
                                                    sigma_list, dataKint)
                sys.stdout.write('\n')

                print 'Running Shift tests'
                for shift in test_interpolants.shift_list:

                    sys.stdout.write('.')
                    sys.stdout.flush()
                    dataXint = calculate_interpolated_image_g1g2sigma(
                        sersic_images,
                        psf=psf,
                        dx_input=test_interpolants.pixel_scale,
                        dx_test=dx_test,
                        shear=None,
                        magnification=None,
                        angle=None,
                        shift=shift,
                        x_interpolant=interpolant,
                        padding=padding,
                        image_type=image_type)
                    test_interpolants.print_results(outfile, g1_list, g2_list,
                                                    sigma_list, dataXint)
                    dataKint = calculate_interpolated_image_g1g2sigma(
                        sersic_images,
                        psf=psf,
                        dx_input=test_interpolants.pixel_scale,
                        dx_test=dx_test,
                        shear=None,
                        magnification=None,
                        angle=None,
                        shift=shift,
                        k_interpolant=interpolant,
                        padding=padding,
                        image_type=image_type)
                    test_interpolants.print_results(outfile, g1_list, g2_list,
                                                    sigma_list, dataKint)
                sys.stdout.write('\n')

                print ''

        print "Finished tests for image_type: " + str(image_type)
        print ""
        outfile.close()