def Initialize(params_loc=None): """ This function initialized the windse parameters. Parameters ---------- params_loc : str the location of the parameter yaml file. Returns ------- params : windse.Parameters an overloaded dict containing all parameters. """ parser = argparse.ArgumentParser( usage="windse run [options] params", formatter_class=argparse.RawTextHelpFormatter) parser.add_argument( "params", nargs='?', help='path to yaml file containing the WindSE parameters') parser.add_argument( '-p', dest='updated_parameters', action='append', default=[], help='use this to override a parameter in the yaml file') args, unknown = parser.parse_known_args() if params_loc is None: ### Check if parameters was provided ### if args.params is None: params_loc = "params.yaml" print("Using default parameter location: ./params.yaml") else: params_loc = args.params print("Using parameter location: " + params_loc) ### Initialize WindSE ### windse.initialize(params_loc, updated_parameters=args.updated_parameters) params = windse.windse_parameters return params
params["general"]["name"] = "Box_Domain_Test" ### Set Box Parameters ### Lx = 1000.0 Ly = 1000.0 Lz = 500 params["domain"]["type"] = "box" params["domain"]["x_range"] = [-Lx, Lx] params["domain"]["y_range"] = [-Ly, Ly] params["domain"]["z_range"] = [0.0, Lz] params["domain"]["nx"] = 24 params["domain"]["ny"] = 24 params["domain"]["nz"] = 6 ### Initialize Parameters using those set above ### windse.initialize(params) ### Create the Domain Object ### dom = windse.BoxDomain() ### Check if the object is as expected ### dom.Save() ### Create unit for integration ### V = FiniteElement('Lagrange', dom.mesh.ufl_cell(), 1) V = FunctionSpace(dom.mesh, V) u = Function(V) u.vector()[:] = 1.0 ### Calculate inflow integral ###
params = windse.windse_parameters ### Set General Parameters ### params["general"]["name"] = "Circle_Domain_Test" ### Set Box Parameters ### radius = 1200 params["domain"]["type"] = "circle" params["domain"]["mesh_type"] = "mshr" params["domain"]["radius"] = radius params["domain"]["center"] = [0.0, 0.0] params["domain"]["nt"] = 100 params["domain"]["res"] = 100 ### Initialize Parameters using those set above ### windse.initialize(None) ### Create the Domain Object ### dom = windse.CircleDomain() ### Check if the object is as expected ### dom.Save() ### Check the number of verts and cells ### if dom.mesh.num_cells() != 39300: raise ValueError( "Box domain constructed with unexpected number of cells: " + repr(dom.mesh.num_cells())) if dom.mesh.num_vertices() != 19865: raise ValueError( "Box domain constructed with unexpected number of vertices: " +
from dolfin import * from dolfin_adjoint import * import windse import numpy as np parameters['form_compiler']['quadrature_degree'] = 6 set_log_level(20) ### Create an Instance of the Options ### options = windse.initialize("params3Dterrain.yaml") ### Generate Domain ### dom = windse.ImportedDomain() # dom = windse.BoxDomain() ### Generate Wind Farm ### farm = windse.GridWindFarm(dom) # farm = windse.RandomWindFarm(dom) # farm.Plot(False) ### Warp the mesh and refine ### # dom.Warp(200,0.75) region = [[-1000, 1500], [-1000, 1000], [0, 300]] dom.Refine(1, region=region) # dom.Save() print(len(dom.mesh.coordinates()[:])) print(len(farm.dom.mesh.coordinates()[:])) print(print(farm.dom.mesh.hmin())) # exit()
import windse ### Initialize WindSE ### windse.initialize("params.yaml") ### Generate Domain ### dom = windse.BoxDomain() dom.Save() ### Generate Wind Farm ### farm = windse.RandomWindFarm(dom) farm.Plot(False) ### Function Space ### fs = windse.LinearFunctionSpace(dom) ### Setup Boundary Conditions ### bc = windse.PowerInflow(dom,fs) ### Generate the problem ### problem = windse.StabilizedProblem(dom,farm,fs,bc) ### Solve ### solver = windse.SteadySolver(problem) solver.Solve() ### Output Results ### solver.Save() solver.Plot()
from dolfin import * from dolfin_adjoint import * import windse import numpy as np import inspect parameters['form_compiler']['quadrature_degree'] = 6 set_log_level(20) ### Create an Instance of the Options ### options = windse.initialize("GOparams.yaml") ### Generate Domain ### dom = windse.ImportedDomain() ### Generate Wind Farm ### farm = windse.GridWindFarm(dom) farm.Plot(False) ### Warp the mesh and refine ### region = [[-1000, 1500], [-1000, 1000], [0, 300]] # dom.Refine(1) dom.Refine(1, region=region) dom.Save() ### Function Space ### fs = windse.LinearFunctionSpace(dom) ### Setup Boundary Conditions ### bc = windse.PowerInflow(dom, fs)
from dolfin import * from dolfin_adjoint import * import windse import numpy as np parameters['form_compiler']['quadrature_degree'] = 6 set_log_level(20) ### Initialize WindSE ### windse.initialize("params_small.yaml") ### Generate Domain ### dom = windse.BoxDomain() ### Generate Wind Farm ### # farm = windse.RandomWindFarm(dom) farm = windse.GridWindFarm(dom) # farm.Plot(False) dom.Warp(250,0.75) region = [farm.ex_x,farm.ex_y,[0,250]] dom.Refine(1,region=region) # dom.Save() ### Refine Around the Turbines farm.RefineTurbines(num=1,radius_multiplyer=1.3) ### Function Space ### fs = windse.LinearFunctionSpace(dom)
def run_action(params_loc=None): tick = time.time() ### unload windse if previously loaded ### if "windse" in sys.modules.keys(): del sys.modules["windse"] mods_to_remove = [] for k in sys.modules.keys(): if "windse." in k: mods_to_remove.append(k) for i in range(len(mods_to_remove)): del sys.modules[mods_to_remove[i]] import windse parser = argparse.ArgumentParser( usage="windse run [options] params", formatter_class=argparse.RawTextHelpFormatter) parser.add_argument( "params", nargs='?', help='path to yaml file containing the WindSE parameters') parser.add_argument( '-p', dest='updated_parameters', action='append', default=[], help='use this to override a parameter in the yaml file') args, unknown = parser.parse_known_args() if params_loc is None: ### Check if parameters was provided ### if args.params is None: params_loc = "params.yaml" print("Using default parameter location: ./params.yaml") else: params_loc = args.params print("Using parameter location: " + params_loc) ### Initialize WindSE ### windse.initialize(params_loc, updated_parameters=args.updated_parameters) params = windse.windse_parameters ### Setup the Domain ### if params["domain"].get("interpolated", False): dom_dict = { "box": windse.InterpolatedBoxDomain, "cylinder": windse.InterpolatedCylinderDomain } else: dom_dict = { "box": windse.BoxDomain, "rectangle": windse.RectangleDomain, "cylinder": windse.CylinderDomain, "circle": windse.CircleDomain, "imported": windse.ImportedDomain } dom = dom_dict[params["domain"]["type"]]() ### Setup the Wind farm ### farm_dict = { "grid": windse.GridWindFarm, "random": windse.RandomWindFarm, "imported": windse.ImportedWindFarm } farm = farm_dict[params["wind_farm"]["type"]](dom) farm.Plot(params["wind_farm"].get("display", False)) ### Move and refine the mesh if "refine" in params.keys(): warp_type = params["refine"].get("warp_type", None) warp_strength = params["refine"].get("warp_strength", None) warp_height = params["refine"].get("warp_height", None) warp_percent = params["refine"].get("warp_percent", None) farm_num = params["refine"].get("farm_num", 0) farm_type = params["refine"].get("farm_type", "square") farm_factor = params["refine"].get("farm_factor", 1.0) farm_radius = params["refine"].get("farm_radius", None) refine_custom = params["refine"].get("refine_custom", None) turbine_num = params["refine"].get("turbine_num", 0) turbine_factor = params["refine"].get("turbine_factor", 1.0) if warp_type == "smooth": dom.WarpSmooth(warp_strength) elif warp_type == "split": dom.WarpSplit(warp_height, warp_percent) if refine_custom is not None: for refine_data in refine_custom: if refine_data[1] == "full": dom.Refine(refine_data[0]) else: region = farm.CalculateFarmRegion(refine_data[1], length=refine_data[2]) dom.Refine(refine_data[0], region=region, region_type=refine_data[1]) if farm_num > 0: region = farm.CalculateFarmRegion(farm_type, farm_factor, length=farm_radius) dom.Refine(farm_num, region=region, region_type=farm_type) if turbine_num > 0: farm.RefineTurbines(turbine_num, turbine_factor) ### Finalize the Domain ### dom.Finalize() # dom.Save() # exit() ### Function Space ### func_dict = { "linear": windse.LinearFunctionSpace, "taylor_hood": windse.TaylorHoodFunctionSpace } fs = func_dict[params["function_space"]["type"]](dom) # dom.Save() # exit() ### Setup Boundary Conditions ### bc_dict = { "uniform": windse.UniformInflow, "power": windse.PowerInflow, "log": windse.LogLayerInflow } bc = bc_dict[params["boundary_condition"]["vel_profile"]](dom, fs, farm) ### Generate the problem ### prob_dict = { "stabilized": windse.StabilizedProblem, "taylor_hood": windse.TaylorHoodProblem } problem = prob_dict[params["problem"]["type"]](dom, farm, fs, bc) #,opt=opt) ### Solve ### solve_dict = { "steady": windse.SteadySolver, "multiangle": windse.MultiAngleSolver, "importedvelocity": windse.TimeSeriesSolver } solver = solve_dict[params["solver"]["type"]](problem) solver.Solve() # import dolfin_adjoint as da # tape = da.get_working_tape() # tape.visualise() # exit() ### Perform Optimization ### if params.get("optimization", {}): opt = windse.Optimizer(solver) if params["optimization"].get("taylor_test", False): opt.TaylorTest() if params["optimization"].get("optimize", True): opt.Optimize() if params["optimization"].get("gradient", True): opt.Gradient() tock = time.time() runtime = tock - tick print("Run Complete: {:1.2f} s".format(runtime)) return runtime