Calibrate Delft3D-FLOW Problem with DYCORS in serial

This is an demo to use the DYCORS in serial for the calibraiton of the Delft3D problem.

1. Import the modules that will be used. Users may need to import their own problem modules.

from pods.algorithms.pods.experimental_design import SymmetricLatinHypercube
from pods.algorithms.pods.sot_sync_strategies import SyncStrategyNoConstraintsMutipro
from pods.algorithms.pods.rbf import RBFInterpolant, CubicKernel, LinearTail
from pods.algorithms.pods.adaptive_sampling import CandidateDYCORS
from pods.algorithms.pods.controller import MultiproController
import numpy as np
import os
import logging
from pods.problems.real_functions import *

2. Define the objective evaluation function obj_func(). This function will be called by the optimizaiton algorithm (master) to do evaluation. Users need to set up the home_dir which will be used to nevigate the dir for simualtion evaluations

def obj_func(paramters):
        """
        The function for objective function evaluation.
        :param paramters: A tuple (x, simid, iterid)
                x: the dim dimensional parameter vector
                simid: the index of simulation ID in each iteration
                iterid: the index of iteration ID
                simid and iterid is used control a batch of simulations running simultaneously in each iteration.
        :return: the objective function value [subobj1, subobj2] (a list of multiple sub objectives)
        """
        data = delft3d_flow(dim=4) #Initializaiton for the problem class
        data.home_dir = '/Users/xiawei/Desktop/PODS/examples/'
        x, simid, iterid = paramters
        simid = simid
        iterid = iterid
        result = data.objfunction(x, simid, iterid)
        return result

3. Defin the main() function. Set up the configuration of the algorithms. For serial implementation. Set the nthreads to be 1.

def main():
        # -----------Initilizae logging-----------------#
        if not os.path.exists("./logfiles"):
                os.makedirs("logfiles")
        if os.path.exists("./logfiles/test_simple.log"):
                os.remove("./logfiles/test_simple.log")
        logging.basicConfig(filename="./logfiles/test_simple.log",
                                                level=logging.INFO)

        # -----------Initilizae result saving-----------------#
        if not os.path.exists("./result"):
                os.makedirs("result")

                """ histroy_data folder is needed when you need to
                save the simultion output of each evaluation"""
        if os.path.exists("./result/history_data"):
                os.rmdir("./result/history_data")
        if not os.path.exists("./result/history_data"):
                os.makedirs("./result/history_data")

                """ pysot_tesult.txt file is for saving the objective
                function value and parameter vector of each evaluations"""
        if os.path.exists("./result/pysot_result.txt"):
                os.remove("./result/pysot_result.txt")

        fp = open("./result/pysot_result.txt", "a")
        fp.write("Iteration\tSimID\tObj\tParmaters\n")
        fp.close()

        # -----------set the threads and budget-----------------#
        nthreads = 1 # if it is serial set the nthreads to be 1.
        maxeval = 80
        nsamples = nthreads

        # (1) Initilize the Optimization problem
        data = delft3d_flow(dim=4)
        logging.info(data.info)
        data.home_dir = '/Users/xiawei/Desktop/PODS/examples/'

        # (2) Experimental design
        # Use a symmetric Latin hypercube with 2d + 1 samples
        exp_des = SymmetricLatinHypercube(dim=data.dim, npts=12)

        # (3) Surrogate model
        # Use a cubic RBF interpolant with a linear tail
        surrogate = RBFInterpolant(kernel=CubicKernel, tail=LinearTail, maxp=maxeval)

        # (4) Adaptive sampling
        adapt_samp = CandidateDYCORS(data=data, numcand=1000 * data.dim)

        # (5) Use the multiprocessing-based sychronous strategy without non-bound constraints
        strategy = SyncStrategyNoConstraintsMutipro(obj_func,
                                                                                                worker_id=0, data=data, maxeval=maxeval, nsamples=nsamples,
                                                                                                exp_design=exp_des, response_surface=surrogate,
                                                                                                sampling_method=adapt_samp)

        # (6) Use the multiprocessing-based sychronous controller
        controller = MultiproController()
        controller.strategy = strategy

        # Run the optimization strategy
        result = controller.run()
        print "result", result



if __name__ == "__main__":
   main()