def testGalaxyPhotometryStandAlone(self):
        objectID = ['Alice', 'Bob', 'Charlie']

        diskSeds = ['Const.80E07.02Z.spec','Inst.80E07.002Z.spec','Burst.19E07.0005Z.spec']
        diskMagNorm = [24.2, 28.1, 29.0]
        diskAv = [3.1, 3.2, 2.9]

        bulgeSeds = ['Inst.80E07.002Z.spec','Const.80E07.02Z.spec','Burst.19E07.0005Z.spec']
        bulgeMagNorm = [25.0, 28.0, 27.1]
        bulgeAv = [2.8, 3.2, 3.3]

        agnSeds = ['agn.spec', 'agn.spec', 'agn.spec']
        agnMagNorm = [22.0, 23.0, 26.0]

        redshift = [0.2, 0.3, 1.1]
        cosmologicalDistanceModulus = [5.0, 3.0, 4.5]

        diskSedsDummy = ['Inst.80E07.002Z.spec','Burst.19E07.0005Z.spec']
        diskMagNormDummy = [28.1, 29.0]
        diskAvDummy = [3.2, 2.9]

        bulgeSedsDummy = ['Const.80E07.02Z.spec','Burst.19E07.0005Z.spec']
        bulgeMagNormDummy = [28.0, 27.1]
        bulgeAvDummy = [3.2, 3.3]

        agnSeds = ['agn.spec', 'agn.spec', 'agn.spec']
        agnMagNorm = [22.0, 23.0, 26.0]

        agnSedsDummy = ['agn.spec', 'agn.spec']
        agnMagNormDummy = [22.0, 26.0]

        redshiftDummy = [0.3, 1.1]
        cosmologicalDistanceModulusDummy = [3.0, 4.5]

        phot = PhotometryGalaxies()
        phot.loadTotalBandpassesFromFiles(bandpassNames=['u','g','r','i','z','y'])

        self.assertRaises(RuntimeError, phot.calculate_magnitudes, objectID,
                          diskNames=diskSedsDummy, diskMagNorm=diskMagNorm, diskAv=diskAv,
                          redshift=redshift)

        self.assertRaises(RuntimeError, phot.calculate_magnitudes, objectID,
                          diskNames=diskSeds, diskMagNorm=diskMagNormDummy, diskAv=diskAvDummy,
                          redshift=redshift)

        self.assertRaises(RuntimeError, phot.calculate_magnitudes, objectID,
                          diskNames=diskSeds, diskMagNorm=diskMagNorm, diskAv=diskAvDummy,
                          redshift=redshift)

        self.assertRaises(RuntimeError, phot.calculate_magnitudes, objectID,
                          bulgeNames=bulgeSedsDummy, bulgeMagNorm=bulgeMagNorm, bulgeAv=bulgeAv,
                          redshift=redshift)

        self.assertRaises(RuntimeError, phot.calculate_magnitudes, objectID,
                          bulgeNames=bulgeSeds, bulgeMagNorm=bulgeMagNormDummy, bulgeAv=bulgeAv,
                          redshift=redshift)

        self.assertRaises(RuntimeError, phot.calculate_magnitudes, objectID,
                          bulgeNames=bulgeSeds, bulgeMagNorm=bulgeMagNorm, bulgeAv=bulgeAvDummy,
                          redshift=redshift)

        self.assertRaises(RuntimeError, phot.calculate_magnitudes, objectID,
                          agnNames=agnSedsDummy, agnMagNorm=agnMagNorm)

        self.assertRaises(RuntimeError, phot.calculate_magnitudes, objectID,
                          agnNames=agnSeds, agnMagNorm=agnMagNormDummy)

        self.assertRaises(RuntimeError, phot.calculate_magnitudes, objectID,
                          bulgeNames=bulgeSeds, bulgeMagNorm=bulgeMagNorm, bulgeAv=bulgeAv,
                          redshift=redshiftDummy)

        self.assertRaises(RuntimeError, phot.calculate_magnitudes, objectID,
                          bulgeNames=bulgeSeds, bulgeMagNorm=bulgeMagNorm, bulgeAv=bulgeAv,
                          redshift=redshift, cosmologicalDistanceModulus=cosmologicalDistanceModulusDummy)

        self.assertRaises(RuntimeError, phot.calculate_magnitudes, objectID,
                          bulgeNames=bulgeSeds, bulgeMagNorm=bulgeMagNorm, redshift=redshift)
        self.assertRaises(RuntimeError, phot.calculate_magnitudes, objectID,
                          bulgeNames=bulgeSeds, bulgeAv=bulgeAv, redshift=redshift)

        self.assertRaises(RuntimeError, phot.calculate_magnitudes, objectID,
                          diskNames=diskSeds, diskMagNorm=diskMagNorm, redshift=redshift)
        self.assertRaises(RuntimeError, phot.calculate_magnitudes, objectID,
                          diskNames=diskSeds, diskAv=diskAv, redshift=redshift)

        self.assertRaises(RuntimeError, phot.calculate_magnitudes, objectID,
                          agnNames=agnSeds, redshift=redshift)

        self.assertRaises(RuntimeError, phot.calculate_magnitudes, objectID,
                          bulgeNames=bulgeSeds, bulgeMagNorm=bulgeMagNorm, bulgeAv=bulgeAv)
        self.assertRaises(RuntimeError, phot.calculate_magnitudes, objectID,
                          diskNames=diskSeds, diskMagNorm=diskMagNorm, diskAv=diskAv)
        self.assertRaises(RuntimeError, phot.calculate_magnitudes, objectID,
                          agnNames=agnSeds, agnMagNorm=agnMagNorm)

        bulgeNamePossibilities = [bulgeSeds, None]
        diskNamePossibilities = [diskSeds, None]
        agnNamePossibilities = [agnSeds, None]

        for bulgeNames in bulgeNamePossibilities:
            for diskNames in diskNamePossibilities:
                for agnNames in agnNamePossibilities:

                    magnitudes = phot.calculate_magnitudes(objectID, redshift=redshift,
                                                           bulgeNames=bulgeNames, bulgeMagNorm=bulgeMagNorm, bulgeAv=bulgeAv,
                                                           diskNames=diskNames, diskMagNorm=diskMagNorm, diskAv=diskAv,
                                                           agnNames=agnNames, agnMagNorm=agnMagNorm)

                    for name in objectID:
                        for i in range(len(phot.bandpassDict)):
                            flux=0.0
                            if bulgeNames is None:
                                self.assertTrue(numpy.isnan(magnitudes[name]['bulge'][i]))
                            else:
                                self.assertTrue(magnitudes[name]['bulge'][i] is not None)
                                self.assertFalse(numpy.isnan(magnitudes[name]['bulge'][i]))
                                flux += numpy.power(10.0, -0.4*(magnitudes[name]['bulge'][i]-22.0))

                            if diskNames is None:
                                self.assertTrue(numpy.isnan(magnitudes[name]['disk'][i]))
                            else:
                                self.assertTrue(magnitudes[name]['disk'][i] is not None)
                                self.assertFalse(numpy.isnan(magnitudes[name]['disk'][i]))
                                flux += numpy.power(10.0, -0.4*(magnitudes[name]['disk'][i]-22.0))

                            if agnNames is None:
                                self.assertTrue(numpy.isnan(magnitudes[name]['agn'][i]))
                            else:
                                self.assertTrue(magnitudes[name]['agn'][i] is not None)
                                self.assertFalse(numpy.isnan(magnitudes[name]['agn'][i]))
                                flux += numpy.power(10.0, -0.4*(magnitudes[name]['agn'][i]-22.0))
    def testGalaxyPhotometricUncertainties(self):
        """
        Test in the case of a catalog of galaxies
        """
        lsstDefaults = LSSTdefaults()
        phot = PhotometryGalaxies()
        phot.loadTotalBandpassesFromFiles()
        galDB = testGalaxyTileDBObj(driver=self.driver, host=self.host, database=self.dbName)
        galCat = testGalaxyCatalog(galDB, obs_metadata=self.obs_metadata)
        imsimband = Bandpass()
        imsimband.imsimBandpass()
        ct = 0
        for line in galCat.iter_catalog():
            bulgeSedName = line[50]
            diskSedName = line[51]
            agnSedName = line[52]
            magNormBulge = line[53]
            magNormDisk = line[54]
            magNormAgn = line[55]
            avBulge = line[56]
            avDisk = line[57]
            redshift = line[58]

            bulgeSed = Sed()
            bulgeSed.readSED_flambda(os.path.join(lsst.utils.getPackageDir('sims_sed_library'),
                                     defaultSpecMap[bulgeSedName]))
            fNorm=bulgeSed.calcFluxNorm(magNormBulge, imsimband)
            bulgeSed.multiplyFluxNorm(fNorm)

            diskSed = Sed()
            diskSed.readSED_flambda(os.path.join(lsst.utils.getPackageDir('sims_sed_library'),
                                    defaultSpecMap[diskSedName]))
            fNorm = diskSed.calcFluxNorm(magNormDisk, imsimband)
            diskSed.multiplyFluxNorm(fNorm)

            agnSed = Sed()
            agnSed.readSED_flambda(os.path.join(lsst.utils.getPackageDir('sims_sed_library'),
                                   defaultSpecMap[agnSedName]))
            fNorm = agnSed.calcFluxNorm(magNormAgn, imsimband)
            agnSed.multiplyFluxNorm(fNorm)

            phot.applyAv([bulgeSed, diskSed], [avBulge, avDisk])
            phot.applyRedshift([bulgeSed, diskSed, agnSed], [redshift, redshift, redshift])

            numpy.testing.assert_almost_equal(bulgeSed.wavelen, diskSed.wavelen)
            numpy.testing.assert_almost_equal(bulgeSed.wavelen, agnSed.wavelen)

            fl = bulgeSed.flambda + diskSed.flambda + agnSed.flambda

            totalSed = Sed(wavelen=bulgeSed.wavelen, flambda=fl)

            sedList = [totalSed, bulgeSed, diskSed, agnSed]

            for i, spectrum in enumerate(sedList):
                if i==0:
                    msgroot = 'failed on total'
                elif i==1:
                    msgroot = 'failed on bulge'
                elif i==2:
                    msgroot = 'failed on disk'
                elif i==3:
                    msgroot = 'failed on agn'

                for j, b in enumerate(self.bandpasses):
                    controlSigma = calcMagError_sed(spectrum, self.totalBandpasses[j],
                                             self.skySeds[j],
                                             self.hardwareBandpasses[j],
                                             seeing=lsstDefaults.seeing(b),
                                             photParams=PhotometricParameters())

                    testSigma = line[26+(i*6)+j]
                    msg = '%e neq %e; ' % (testSigma, controlSigma) + msgroot
                    self.assertAlmostEqual(testSigma, controlSigma, 10, msg=msg)
                    ct += 1

        self.assertTrue(ct>0)