Пример #1
0
    def initRun(self, run):
        if run.params.qoi_knots.lower() == "uniform":
            fnKnots = lambda beta: misc.knots_uniform(misc.lev2knots_linear(1+beta),
                                                      0, 1, 'nonprob')
        else:
            assert(run.params.qoi_knots.lower() == "cc")
            fnKnots = lambda beta: misc.knots_CC(misc.lev2knots_doubling(1+beta),
                                                 0, 1, 'nonprob')

        self.misc = misc.MISCSampler(d=0, fnKnots=fnKnots, min_dim=run.params.min_dim)

        b = [9.0, 7.25, 1.85, 7.03, 2.04, 4.3]
        fn = [self.func_oscillatory, self.func_productpeak,
              self.func_cornerpeak, self.func_gauss, self.func_cont,
              self.func_discont]
        self.func = lambda inds, M, r=run: fn[run.params.qoi_func-1](r, inds, M)

        np.random.seed(run.params.qoi_seed)
        run.params.qoi_w = 1./np.arange(1.,run.params.qoi_dim+1, dtype=np.float)#np.random.random(size=run.params.qoi_dim)
        run.params.qoi_c = np.arange(1,run.params.qoi_dim+1, dtype=np.float) #np.random.random(size=run.params.qoi_dim)
        run.params.qoi_c *= b[run.params.qoi_func-1] / np.sum(run.params.qoi_c)

        run.params.qoi_c = np.array([2.71,0.16,3.42,2.71])
        run.params.qoi_w = np.array([0.42,0.72,0.01,0.3])

        run.setFunctions(ExtendLvls=lambda lvls, r=run: self.extendLvls(run, lvls),
                         WorkModel=lambda lvls, r=run: self.workModel(run, lvls),
                         fnSampleLvl=self.mySampleQoI)
        self.profCalc = setutil.TDProfCalculator(np.ones(run.params.qoi_dim))
        return
Пример #2
0
    def initRun(self, run):
        fnKnots = lambda beta: misc.knots_CC(misc.lev2knots_doubling(1 + beta),
                                             0, 1, 'nonprob')
        self.misc = misc.MISCSampler(d=0,
                                     fnKnots=fnKnots,
                                     min_dim=run.params.min_dim)

        b = [9.0, 7.25, 1.85, 7.03, 2.04, 4.3]
        fn = [
            self.func_oscillatory, self.func_productpeak, self.func_cornerpeak,
            self.func_gauss, self.func_cont, self.func_discont
        ]
        self.func = lambda inds, M, r=run: fn[run.params.qoi_func - 1](r, inds,
                                                                       M)

        np.random.seed(run.params.qoi_seed)
        run.params.qoi_w = 1. / np.arange(
            1., run.params.qoi_dim + 1,
            dtype=np.float)  #np.random.random(size=run.params.qoi_dim)
        run.params.qoi_c = np.arange(
            1, run.params.qoi_dim + 1,
            dtype=np.float)  #np.random.random(size=run.params.qoi_dim)
        run.params.qoi_c *= b[run.params.qoi_func - 1] / np.sum(
            run.params.qoi_c)

        run.setFunctions(
            ExtendLvls=lambda lvls, r=run: self.extendLvls(run, lvls),
            WorkModel=lambda lvls, r=run: self.workModel(run, lvls),
            fnSampleLvl=self.mySampleQoI)
        self.profCalc = setutil.TDProfCalculator(np.ones(run.params.qoi_dim))
        return
Пример #3
0
    def initRun(self, run):
        self.prev_val = 0
        self.extrapolate_s_dims = 0 if run.params.qoi_problem < 0 else 10
        self.params = run.params
        if run.params.qoi_problem < 0: # Fake mode for deterministic problem
            run.params.qoi_problem = 0

        fnKnots= lambda beta: misc.knots_CC(misc.lev2knots_doubling(1+beta),
                                            -np.sqrt(3), np.sqrt(3))
        self.misc = misc.MISCSampler(d=run.params.min_dim, fnKnots=fnKnots)
        self.sf = SField_Matern(run.params)

        self.d_err_rates = 2.*np.log(run.params.beta) * \
                          np.minimum(1, run.params.qoi_df_nu / run.params.qoi_dim)
        self.d_work_rates = np.log(run.params.beta) * run.params.gamma
        # self.profCalc = setutil.MISCProfCalculator(self.d_err_rates +
        #                                            self.d_work_rates,
        #                                            np.ones(self.extrapolate_s_dims))

        run.setFunctions(ExtendLvls=lambda lvls, r=run: self.extendLvls(run, lvls),
                         WorkModel=lambda lvls, r=run: self.workModel(run, lvls))

        return
Пример #4
0
    def initRun(self, run):
        self.prev_val = 0
        self.extrapolate_s_dims = 0 if run.params.qoi_problem < 0 else 10
        self.params = run.params
        if run.params.qoi_problem < 0:  # Fake mode for deterministic problem
            run.params.qoi_problem = 0

        fnKnots = lambda beta: misc.knots_CC(misc.lev2knots_doubling(1 + beta),
                                             -np.sqrt(3), np.sqrt(3))
        self.misc = misc.MISCSampler(d=run.params.min_dim, fnKnots=fnKnots)
        self.sf = SField_Matern(run.params)

        self.d_err_rates = 2.*np.log(run.params.beta) * \
                          np.minimum(1, run.params.qoi_df_nu / run.params.qoi_dim)
        self.d_work_rates = np.log(run.params.beta) * run.params.gamma
        # self.profCalc = setutil.MISCProfCalculator(self.d_err_rates +
        #                                            self.d_work_rates,
        #                                            np.ones(self.extrapolate_s_dims))

        run.setFunctions(
            ExtendLvls=lambda lvls, r=run: self.extendLvls(run, lvls),
            WorkModel=lambda lvls, r=run: self.workModel(run, lvls))

        return