def U_wash(self):
        """
        U_wash provides a list the following outputs for the Age Calculation: 
            [0]: 233 unfiltered wash in cps
            [1]: 234 unfiltered wash in cps
            [2]: 234 unfiltered wash in cps
            
        """
        #233 wash value
        working_a = isofilter.IsoFilter(self.filename_U, "C", 44)
        self.three_wash = working_a.getMean()

        #234 wash value
        working_b = isofilter.IsoFilter(self.filename_U, "D", 44)
        self.four_wash = working_b.getMean()

        #235 wash value
        working_c = isofilter.IsoFilter(self.filename_U, "E", 44)
        self.five_wash = working_c.getMean()

        while self.inquiry:
            print "BACKGROUND VALUES FOR AGE CALC:"
            print "233 wash value: " + str(self.three_wash) + ' cps'
            print "234 wash value: " + str(self.four_wash) + ' cps'
            print "235 wash value: " + str(self.five_wash) + ' cps'
            break

        lstU_wash = [self.three_wash, self.four_wash, self.five_wash]

        return lstU_wash
    def Th_wash(self):
        """
        Th_wash provides a list of the following outputs for the Age Calculation: 
            [0]: 230 unfiltered wash in cpm 
                
        """
        #230 wash value
        working_a = isofilter.IsoFilter(self.filename_Th, "D", 28)
        self.zero_wash = working_a.getMean()

        #calculate "darknoise" value for Age calculation
        self.darknoise = self.zero_wash * 60

        while self.inquiry:
            print "230 wash value/darknoise: " + str(self.darknoise) + ' cpm'
            break

        return self.darknoise
    def __init__(self, spike_input, AS_input, filename_input, inquiry_input):

        spike = str(spike_input)

        spike_six_three_dictionary = {
            "DIII-B": 1.008398,
            "DIII-A": 1.008398,
            "1I": 1.010128,
            "1H": 1.010128
        }

        #derives 236/233 value of spike from preset dictionary
        if spike in spike_six_three_dictionary:
            self.spike = float(spike_six_three_dictionary[spike])
        else:
            print 'ERROR: You did not enter a valid spike option'

        #allows you the ability to print as you go
        inquiry = str(inquiry_input)

        if inquiry.lower() == "y":
            self.inquiry = True
        else:
            self.inquiry = False
            print "Program ran but without printing"

        #AS is the abundant sensitivity 237/238, measured through the AS method on the ICP-MS
        self.AS = float(AS_input)

        #uses the filename given for your U run
        filename = str(filename_input)

        #236/233 filtered measured mean and 2s error
        working = isofilter.IsoFilter(filename, "G", 44)
        a = working.getMean()
        b = working.getStanddev()
        c = working.getCounts()
        self.six_three_mean_meas = working.Filtered_mean(a, b, c)
        self.six_three_err_meas = working.Filtered_err(a, b, c)

        #235/233 filtered measured mean and 2s error
        working_b = isofilter.IsoFilter(filename, "H", 44)
        a = working_b.getMean()
        b = working_b.getStanddev()
        c = working_b.getCounts()
        self.five_three_mean_meas = working_b.Filtered_mean(a, b, c)
        self.five_three_err_meas = working_b.Filtered_err(a, b, c)

        #234/235 filtered measured mean and 2s error
        working_c = isofilter.IsoFilter(filename, "I", 44)
        a = working_c.getMean()
        b = working_c.getStanddev()
        c = working_c.getCounts()
        self.four_five_mean_meas = working_c.Filtered_mean(a, b, c)
        self.four_five_err_meas = working_c.Filtered_err(a, b, c)
        self.four_five_counts = working_c.Filtered_counts(a, b, c)

        #233 unfiltered mean and counts
        working_d = isofilter.IsoFilter(filename, "C", 44)
        self.three_mean_meas = working_d.getMean()
        self.three_counts = working_d.getCounts()

        #constants to be used throughout the class
        self.wt_235 = 235.043924
        self.wt_233 = 233.039629
        self.wt_236 = 236.045563
        self.wt_234 = 234.040947
        self.eight_five_rat = 137.83
        self.AS_six_eight = self.AS / 5
        self.AS_four_eight = self.AS / 20
        self.eight_five_rat_err_rel = 0.0003
    def __init__(self, spike_input, AS_input, filename_input, inquiry_input,
                 lstU_Th):

        spike = str(spike_input)

        spike_six_three_dictionary = {
            "DIII-B": 1.008398,
            "DIII-A": 1.008398,
            "1I": 1.010128,
            "1H": 1.010128
        }

        #derives 236/233 value of spike from preset dictionary
        if spike in spike_six_three_dictionary:
            self.spike = float(spike_six_three_dictionary[spike])
        else:
            print 'ERROR: You did not enter a valid spike option'

        #allows you the ability to print as you go
        inquiry = str(inquiry_input)

        if inquiry.lower() == "y":
            self.inquiry = True
        else:
            self.inquiry = False
            print "Program ran but without printing"

        #AS is the abundant sensitivity 237/238, measured through the AS method on the ICP-MS
        self.AS = float(AS_input)

        #uses the filename given for your Th run
        filename = str(filename_input)

        #Compiles the values of the lstU_Th provided by your U_normalization_forTh function
        self.six_three_mean_meas = lstU_Th[0]
        self.six_three_err_meas = lstU_Th[1]
        self.five_three_norm = lstU_Th[2]
        self.five_three_norm_err = lstU_Th[3]
        self.six_three_corr = lstU_Th[4]
        self.six_three_corr_err = lstU_Th[5]

        #Note: Hai's macro only filters 230/229 column

        #230/232 filtered measured mean and 2s error
        working = isofilter.IsoFilter(filename, "G", 28)
        self.zero_two_mean_meas = working.getMean() / 1.02
        self.zero_two_counts = working.getCounts()
        self.zero_two_standdev_meas = working.getStanddev()
        self.zero_two_rel_err_meas = (
            2 * self.zero_two_standdev_meas /
            (self.zero_two_counts**0.5)) / self.zero_two_mean_meas
        self.zero_two_rel_err = max(self.zero_two_rel_err_meas, 0.02)
        self.zero_two_err_meas = self.zero_two_mean_meas * self.zero_two_rel_err

        #230/229 filtered measured mean and 2s error
        working_b = isofilter.IsoFilter(filename, "E", 28)
        a = working_b.getMean()
        b = working_b.getStanddev()
        c = working_b.getCounts()
        self.zero_nine_mean_meas = working_b.Filtered_mean(a, b, c)
        self.zero_nine_err_meas = working_b.Filtered_err(a, b, c)

        #232/229 filtered measured mean and 2s error
        working_c = isofilter.IsoFilter(filename, "F", 28)
        self.nine_two_mean_meas = working_c.getMean()
        self.two_nine_mean_meas = 1 / (self.nine_two_mean_meas / 1.02)
        self.two_nine_counts = working.getCounts()
        self.nine_two_standdev_meas = working_c.getStanddev()
        self.nine_two_rel_err_meas = (
            2 * self.nine_two_standdev_meas /
            (self.two_nine_counts**0.5)) / self.nine_two_mean_meas
        self.two_nine_rel_err = max(self.nine_two_rel_err_meas, 0.02)
        self.two_nine_err_meas = self.two_nine_mean_meas * self.two_nine_rel_err

        #229 unfiltered mean and counts
        working_d = isofilter.IsoFilter(filename, "C", 28)
        self.nine_mean_meas = working_d.getMean()
        self.nine_counts = working_d.getCounts()

        #constants to be used throughout the class
        self.wt_233 = 233.039629
        self.wt_236 = 236.045563
        self.wt_229 = 229.031756
        self.wt_230 = 230.033128
        self.wt_232 = 232.038051
        self.AS_zero_nine = self.AS
        self.AS_zero_two = self.AS_zero_nine / 5
        self.AS_two_nine = self.AS_zero_two / 3
        self.eight_five_rat = 137.83
        self.eight_five_rat_err_rel = 0.0003