class BM_SCENE_CFDSolver_RAS(bpy.types.PropertyGroup):
items_list = makeTuples(["kEpsilon", "kOmega", "kOmegaSST"])
model: bpy.props.EnumProperty(name="rasModel", items=items_list, description="RAS Turbulence Model", default="kEpsilon")
def drawMenu(self, layout):
layout.row().prop(self, "model")
class BM_OBJ_CFD_MESH(bpy.types.PropertyGroup):
meshMinLevel: bpy.props.IntProperty(name="min",
min=0,
default=0,
description="meshMaxLevel",
update=setMeshMinMax)
meshMaxLevel: bpy.props.IntProperty(name="max",
min=0,
default=0,
description="meshMaxLevel",
update=setMeshMinMax)
nSurfaceLayers: bpy.props.IntProperty(name="nSurfaceLayers",
min=0,
default=0,
description="nSurfaceLayers")
makeRefinementRegion: bpy.props.BoolProperty(
name="refinementRegion",
default=False,
description="Make this object a Refinement Region")
makeCellSet: bpy.props.BoolProperty(
name="cellSet",
default=False,
description="Make this object a cellSet")
items_list = makeTuples(["distance", "inside", "outside", "surface"])
refinementMode: bpy.props.EnumProperty(name="mode",
items=items_list,
description="Preset",
default="inside",
update=setLevel)
distanceLevels: bpy.props.StringProperty(
name="levels",
description="Levels at Distances: (distance level)",
default="((1 4))")
def drawMenu(self, layout):
sc = bpy.context.scene
L = layout.box()
L.row().label(text="Mesh Levels:")
split = L.split()
split.column().prop(self, "meshMinLevel")
split.column().prop(self, "meshMaxLevel")
if sc.ODS_CFD.mesh.addLayers:
split.column().prop(self, "nSurfaceLayers")
# Make Refinement Region
split.column().prop(self, "makeRefinementRegion")
split.column().prop(self, "makeCellSet")
if self.makeRefinementRegion or self.makeCellSet:
L = layout.box()
row = L.row()
row.prop(self, "refinementMode")
if self.makeRefinementRegion:
row.prop(self, "distanceLevels")
layout.row().operator(
"scene.cfdoperators",
text="Copy to Selected").command = "copyMeshLevels"
class BM_MAT_RAD(bpy.types.PropertyGroup):
items_list = makeTuples(
["Plastic", "Glass", "Metal", "Mirror", "Trans", "None"])
type: bpy.props.EnumProperty(name="Type",
items=items_list,
description="Material Type",
default="Plastic")
Plastic: bpy.props.PointerProperty(type=BM_MAT_RAD_PLASTIC)
Glass: bpy.props.PointerProperty(type=BM_MAT_RAD_GLASS)
Metal: bpy.props.PointerProperty(type=BM_MAT_RAD_METAL)
Mirror: bpy.props.PointerProperty(type=BM_MAT_RAD_MIRROR)
Trans: bpy.props.PointerProperty(type=BM_MAT_RAD_TRANS)
def drawMenu(self, layout):
layout.row().prop(self, "type", text="Type", expand=False)
if self.type == "None":
return None
t = getattr(self, self.type)
t.drawMenu(layout)
return None
def textRAD(self):
if self.type == "None":
text = ""
else:
t = getattr(self, self.type)
text = t.textRAD()
return text
class BM_MAT_RAD_PLASTIC(bpy.types.PropertyGroup):
items_list = makeTuples(["VeryRough","Rough","MediumRough","MediumSmooth","Smooth","VerySmooth"])
roughness: bpy.props.EnumProperty(
name="Roughness",
items=items_list,description="Influences only External Convection Coefficients",
default="MediumRough")
specular: bpy.props.FloatProperty(
name="Specularity",
description="Specularity (>0.1 is usually not realistic for Opaque, >0.9 typical for metal)",
default=0.0, min=0.0, max=1.0, precision=4)
def drawMenu(self, layout):
layout.row().prop(self, "roughness")
layout.row().prop(self, "specular")
def getMatRGB(self):
m = self.id_data
(r,g,b,a) = m.diffuse_color
return (r,g,b)
def roughValue(self):
roughDescriptions = ["VeryRough","Rough","MediumRough","MediumSmooth","Smooth","VerySmooth"]
roughValues = [0.5, 0.35, 0.2, 0.14, 0.07, 0.0]
return roughValues[roughDescriptions.index(self.roughness)]
def textRAD(self):
# Get the roughness and rgb values
(r,g,b) = self.getMatRGB()
text = "\n## material conversion from blender \"diffuse_color\" property"
text += "\nvoid plastic %s"%(formatName(self.id_data.name))
text += "\n0\n0\n5"
text += " %.4f %.4f %.4f %.3f %.3f\n"%(r,g,b,self.specular,self.roughValue())
return text
class BM_OBJ_CFD_PATCHFIELD(bpy.types.PropertyGroup):
volScalarField: bpy.props.PointerProperty(type=ODS_CFD_PATCH_SCALAR)
volVectorField: bpy.props.PointerProperty(type=ODS_CFD_PATCH_VECTOR)
items_list = makeTuples(["volVectorField", "volScalarField"])
classType: bpy.props.EnumProperty(name="classType",
items=items_list,
description="classType",
default="volScalarField")
def setValue(self, value, var='value'):
return getattr(self, self.classType).setValue(value, var=var)
def setPatchType(self, patchType):
setattr(getattr(self, self.classType), 'patchType', patchType)
return None
def getText(self):
return getattr(self, self.classType).getText()
def draw(self, layout, header=True):
if header:
row = layout.row()
#row.label(text="%s (%s)"%(self.name, self.classType))
row.prop(self, "name", text="")
row.label(text=self.classType)
c = getattr(self, self.classType)
c.draw(layout, header=header)
return None
class BM_SCENE_CFD(bpy.types.PropertyGroup):
mesh: bpy.props.PointerProperty(type=BM_SCENE_CFDMesh)
control: bpy.props.PointerProperty(type=BM_SCENE_CFDControl)
solver: bpy.props.PointerProperty(type=BM_SCENE_CFDSolver)
system: bpy.props.PointerProperty(type=BM_SCENE_CFDSystem)
postproc: bpy.props.PointerProperty(type=BM_SCENE_CFDPostProc)
items_list = makeTuples(
["System", "Solver", "Mesh", "Control", "PostProc"])
menu: bpy.props.EnumProperty(name="CFDMenu",
items=items_list,
description="CFD menu categories",
default="System")
showCoeffs: bpy.props.BoolProperty(
name="showCoeffs",
description="Show advanced wall coefficients",
default=False)
def drawMenu(self, layout):
layout.row().prop(self, "menu", expand=True)
c = getattr(self, self.menu.lower())
c.drawMenu(layout)
return None
class BM_SCENE_CFDSolver_LES(bpy.types.PropertyGroup):
items_list = makeTuples(["Smagorinsky", "oneEqEddy", "SpalartAllmaras"])
model: bpy.props.EnumProperty(name="lesModel", items=items_list, description="LES Turbulence Model", default="oneEqEddy")
def drawMenu(self, layout):
layout.row().prop(self, "model")
return None
class BM_SCENE_SITE(bpy.types.PropertyGroup):
terrain: bpy.props.EnumProperty(
name="Terrain",
items=makeTuples(["Suburbs", "Country", "City", "Ocean", "Urban"]),
description="Set terrain type",
default="Country")
buildingName: bpy.props.StringProperty(name="Name",
default="Undefined",
maxlen=128,
description="Building Name")
northAxis: bpy.props.FloatProperty(
name="North",
description="True north axis clockwise relative to 0deg=Y+",
subtype="ANGLE",
update=recalcsunpath)
location: bpy.props.StringProperty(name="Location",
default="Undefined",
maxlen=32,
description="Site Location Name")
latitude: bpy.props.FloatProperty(name="Latitude",
step=1,
precision=5,
description="Site Latitude",
default=-31.95224,
min=-90.0,
max=90.0,
update=recalcsunpath)
longitude: bpy.props.FloatProperty(name="Longitude",
step=1,
precision=5,
description="Site Longitude",
default=115.8614,
min=-180.0,
max=180.0,
update=recalcsunpath)
timezone: bpy.props.FloatProperty(name="TimeZone",
step=1,
precision=2,
description="Time Zone",
default=8.0,
min=-12.0,
max=12.0,
update=recalcsunpath)
elevation: bpy.props.FloatProperty(name="Elevation",
step=1,
precision=2,
description="Site Elevation")
def idfText(self):
text = "Site:Location,\n%s,\n%s,\n%s,\n%s,\n%s;\n\n" % (
self.location, self.latitude, self.longitude, self.timezone,
self.elevation)
return text
class SCENE_OT_selectObjects(bpy.types.Operator):
'''Select Objects based upon criteria'''
bl_idname = "scene.select_objects"
bl_label = "Select Objects By:"
bl_options = {'REGISTER', 'UNDO'}
items_list = makeTuples(["None", "Construction", "Type", "Zone", "No Faces"])
method: bpy.props.EnumProperty(name="method", default="None", items=items_list, description="Select Objects of Same:")
def draw(self, context):
layout = self.layout
layout.row().label(text='Objects of Same:')
layout.row().prop(self, 'method', text="")
def execute(self, context):
o = context.active_object
if o is None:
return {'FINISHED'}
if self.method == "Construction":
selectUtils.selectObjectsOfSameConstruction(o)
if self.method == "Type":
if hasattr(bpy.context.scene, 'ODS_EP'):
selectUtils.selectObjectsOfSameType(o)
else:
self.report({'ERROR'}, 'Requires the EnergyPlus Module')
return {'FINISHED'}
if self.method == "Zone":
if hasattr(bpy.context.scene, 'ODS_EP'):
selectUtils.selectObjectsOfZone(o)
else:
self.report({'ERROR'}, 'Requires the EnergyPlus Module')
return {'FINISHED'}
if self.method == "No Faces":
sc = bpy.context.scene
# Deselect all objects in the scene
for ob in sc.objects:
if ob.type == 'MESH':
if len(ob.data.polygons) == 0:
ob.select = True
else:
ob.select = False
return {'FINISHED'}
def invoke(self, context, event):
self.execute(context)
return {'FINISHED'}
class ODS_CFD_FIELDS(bpy.types.PropertyGroup):
volScalarField: bpy.props.PointerProperty(type=ODS_CFD_FIELD_SCALAR)
volVectorField: bpy.props.PointerProperty(type=ODS_CFD_FIELD_VECTOR)
items_list = makeTuples(["volVectorField", "volScalarField"])
classType: bpy.props.EnumProperty(name="classType", items=items_list, description="classType", default="volScalarField")
dim: bpy.props.StringProperty(name="dim", default="[0,1,-1,0,0,0,0]")
def setValue(self, value):
c = getattr(self, self.classType)
return c.setValue(value)
def draw(self, layout):
row = layout.row()
row.prop(self, "name")
row.prop(self, "classType")
c = getattr(self, self.classType)
c.draw(layout)
return None
class ODS_CFD_PATCH_VECTOR(bpy.types.PropertyGroup):
slip: bpy.props.PointerProperty(type=ODS_CFD_PATCH_VECTOR_slip)
zeroGradient: bpy.props.PointerProperty(
type=ODS_CFD_PATCH_VECTOR_zeroGradient)
fixedValue: bpy.props.PointerProperty(type=ODS_CFD_PATCH_VECTOR_fixedValue)
inletOutlet: bpy.props.PointerProperty(
type=ODS_CFD_PATCH_VECTOR_inletOutlet)
other: bpy.props.PointerProperty(type=ODS_CFD_PATCH_VECTOR_other)
items_list = makeTuples(
["fixedValue", "zeroGradient", "inletOutlet", "slip", "other"])
patchType: bpy.props.EnumProperty(name="patchType",
items=items_list,
description="patchType",
default="fixedValue")
localCoords: bpy.props.BoolProperty(name="localCoords",
description="localCoords",
default=False)
flowRate: bpy.props.BoolProperty(name="flowRate",
description="flowRate",
default=False)
def setValue(self, value, var='value'):
return getattr(self, self.patchType).setValue(value, var=var)
def draw(self, layout, header=True):
if header:
layout.row().prop(self, "patchType")
c = getattr(self, self.patchType)
if c.draw(layout):
# Draw settings for local coordinates
split = layout.split()
col = split.column()
col.prop(self, "localCoords", text="Local Coordinates")
col = split.column()
col.prop(self, "flowRate", text="Total Flux")
return None
def getText(self):
return getattr(self, self.patchType).getText()
class ODS_CFD_PATCH_SCALAR(bpy.types.PropertyGroup):
zeroGradient: bpy.props.PointerProperty(
type=ODS_CFD_PATCH_SCALAR_zeroGradient)
fixedValue: bpy.props.PointerProperty(type=ODS_CFD_PATCH_SCALAR_fixedValue)
kqRWallFunction: bpy.props.PointerProperty(
type=ODS_CFD_PATCH_SCALAR_kqRWallFunction)
epsilonWallFunction: bpy.props.PointerProperty(
type=ODS_CFD_PATCH_SCALAR_epsilonWallFunction)
omegaWallFunction: bpy.props.PointerProperty(
type=ODS_CFD_PATCH_SCALAR_omegaWallFunction)
nutkWallFunction: bpy.props.PointerProperty(
type=ODS_CFD_PATCH_SCALAR_nutkWallFunction)
inletOutlet: bpy.props.PointerProperty(
type=ODS_CFD_PATCH_SCALAR_inletOutlet)
other: bpy.props.PointerProperty(type=ODS_CFD_PATCH_SCALAR_other)
items_list = makeTuples([
"fixedValue", "zeroGradient", "inletOutlet", "kqRWallFunction",
"epsilonWallFunction", "omegaWallFunction", "nutkWallFunction", "other"
])
patchType: bpy.props.EnumProperty(name="patchType",
items=items_list,
description="patchType",
default="fixedValue")
def setValue(self, value, var='value'):
return getattr(self, self.patchType).setValue(value, var=var)
def draw(self, layout, header=True):
if header:
layout.row().prop(self, "patchType")
c = getattr(self, self.patchType)
c.draw(layout)
return None
def getText(self):
return getattr(self, self.patchType).getText()
class BM_SCENE_CFDControl(bpy.types.PropertyGroup):
items_list = makeTuples(["firstTime", "latestTime", "startTime"])
startFrom: bpy.props.EnumProperty(name="startFrom",
items=items_list,
description="startFrom",
default="latestTime")
items_list = makeTuples(["endTime", "nextWrite", "writeNow", "noWriteNow"])
stopAt: bpy.props.EnumProperty(name="stopAt",
items=items_list,
description="stopAt",
default="endTime")
items_list = makeTuples(
["timeStep", "runTime", "adjustableRunTime", "cpuTime", "clockTime"])
writeControl: bpy.props.EnumProperty(name="writeControl",
items=items_list,
description="writeControl",
default="timeStep")
items_list = makeTuples(["ascii", "binary"])
writeFormat: bpy.props.EnumProperty(name="writeFormat",
items=items_list,
description="writeFormat",
default="ascii")
items_list = makeTuples(["compressed", "uncompressed"])
writeCompression: bpy.props.EnumProperty(name="writeCompression",
items=items_list,
description="writeCompression",
default="uncompressed")
items_list = makeTuples(["general", "scientific", "fixed"])
timeFormat: bpy.props.EnumProperty(name="timeFormat",
items=items_list,
description="timeFormat",
default="general")
adjustTimeStep: bpy.props.BoolProperty(name="adjustTimeStep",
description="Variable Time Step",
default=False)
maxCo: bpy.props.FloatProperty(name="maxCo",
description="maxCo",
default=0.5,
precision=2)
basic: bpy.props.BoolProperty(name="basicMesh",
description="Basic Run",
default=True)
startTime: bpy.props.FloatProperty(name="startTime",
description="startTime",
default=0.0)
endTime: bpy.props.FloatProperty(name="endTime",
description="endTime",
default=500.0)
deltaT: bpy.props.FloatProperty(name="deltaT",
description="deltaT",
default=1,
precision=3)
writeInterval: bpy.props.FloatProperty(name="writeInterval",
default=50,
description="writeInterval")
purgeWrite: bpy.props.IntProperty(name="purgeWrite",
default=2,
description="purgeWrite")
timePrecision: bpy.props.IntProperty(name="timePrecision",
default=6,
description="timePrecision")
runTimeModifiable: bpy.props.BoolProperty(name="runTimeModifiable",
description="runTimeModifiable",
default=True)
solveFlow: bpy.props.BoolProperty(name="solveFlow",
description="solveFlow",
default=False)
controlLibs: bpy.props.StringProperty(
name="RunTimeLibs",
default="libFanDirectionalPatchField.so",
maxlen=248,
description="Runtime Include Libraries (comma separated)")
writePrecision: bpy.props.IntProperty(name="writePrecision",
default=6,
description="writePrecision")
def drawMenu(self, layout):
sc = bpy.context.scene
split = layout.split()
layout.row().operator("scene.compute_cfdoperators",
text="Run Solver").command = "run_solver"
layout.row().operator(
"scene.compute_cfdoperators",
text="Run Wind Tunnel").command = "run_wind_tunnel"
layout.row().prop(self, "endTime")
#layout.row().prop(self, "stopAt", expand=False)
#row = layout.row()
#row.operator("scene.cfdoperators", text="Write controlDict").command = "write_control_dict"
'''
if self.basic:
row = layout.row()
row.operator("scene.cfdoperators", text="Run Case").command = "basicRun"
row.prop(self, "basic", text="Basic Run")
else:
layout.row().prop(self, "basic", text="Basic Run")
row = layout.row()
row.operator("scene.cfdoperators", text="decomposePar").command = "decomposePar"
row.operator("scene.cfdoperators", text="Run Case").command = "runFoamCase"
row.operator("scene.cfdoperators", text="reconstructPar").command = "reconstructPar"
split = layout.split()
col = split.column()
col.prop(self, "startFrom", expand=False)
col.prop(self, "stopAt", expand=False)
col = split.column()
col.prop(self, "startTime")
col.prop(self, "endTime")
row = layout.row()
row.prop(self, "adjustTimeStep")
if not self.adjustTimeStep:
row.prop(self, "deltaT")
else:
row.prop(self, "maxCo")
row.prop(self, "deltaT", text='maxDeltaT')
row = layout.row()
row.prop(self, "writeControl", expand=False)
row.prop(self, "writeFormat", expand=False)
row = layout.row()
row.prop(self, "writeInterval")
row.prop(self, "purgeWrite")
row = layout.row()
row.prop(self, "writePrecision")
row.prop(self, "writeCompression", expand=False)
row = layout.row()
row.prop(self, "timeFormat", expand=False)
row.prop(self, "timePrecision")
layout.row().prop(self, "runTimeModifiable")
if "ageing" in sc.ODS_CFD.solver.name:
layout.row().prop(self, "solveFlow")
'''
def getText(self):
sc = bpy.context.scene
t = ""
t += "application %s;\n\n" % (sc.ODS_CFD.solver.name)
t += "startFrom %s;\n\n" % (self.startFrom)
t += "startTime %f;\n\n" % (self.startTime)
t += "stopAt %s;\n\n" % (self.stopAt)
t += "endTime %f;\n\n" % (self.endTime)
t += "deltaT %f;\n\n" % (self.deltaT)
if sc.ODS_CFD.control.adjustTimeStep:
t += "adjustTimeStep yes;\n\n"
t += "maxCo %f;\n\n" % (self.maxCo)
t += "maxDeltaT %f;\n\n" % (self.deltaT)
t += "writeControl %s;\n\n" % (self.writeControl)
t += "writeInterval %f;\n\n" % (self.writeInterval)
t += "purgeWrite %i;\n\n" % (self.purgeWrite)
t += "writeFormat %s;\n\n" % (self.writeFormat)
t += "writePrecision %i;\n\n" % (self.writePrecision)
t += "writeCompression %s;\n\n" % (self.writeCompression)
t += "timeFormat %s;\n\n" % (self.timeFormat)
t += "timePrecision %i;\n\n" % (self.timePrecision)
t += "runTimeModifiable %s;\n\n" % (str(
self.runTimeModifiable).lower())
# Added strings for ageingScalarTransportFoam
#if "ageing" in sc.ODS_CFD.solver.name:
# t += "solveFlow %s;"%(str(self.solveFlow).lower())
# Write the added user-defined libraries
libs = []
#if "buoyant" in sc.ODS_CFD.solver.name:
# libs.append("\"libcompressibleTurbulenceModel.so\"")
#if getNumberOfPatchType('outletMappedUniformInlet') > 0 or getNumberOfPatchType('swirl') > 0:
# libs.append("\"libFvPatchFieldsODS.so\"")
t += "libs ( %s );\n" % (" ".join(libs))
# Append information that is in controlDict.append
if 'controlDict.append' in bpy.data.texts:
t += bpy.data.texts['controlDict.append'].as_string()
return t
class BM_SCENE_RAD_FRAME(bpy.types.PropertyGroup):
items_list = makeTuples(["low", "medium", "high"])
quality: bpy.props.EnumProperty(name="quality",
items=items_list,
description="Radiance Output Quality",
default="medium")
items_list = makeTuples(["low", "medium", "high"])
detail: bpy.props.EnumProperty(name="detail",
items=items_list,
description="Radiance Output Detail",
default="medium")
items_list = makeTuples(["low", "medium", "high"])
variability: bpy.props.EnumProperty(
name="variability",
items=items_list,
description="Radiance Output Variability",
default="medium")
items_list = makeTuples(["Interior", "Exterior"])
zoneType: bpy.props.EnumProperty(name="zoneType",
items=items_list,
description="Radiance zoneType",
default="Interior")
penumbras: bpy.props.BoolProperty(name="penumbras",
description="Radiance Output Penumbras",
default=True)
indirect: bpy.props.IntProperty(name="indirect",
min=1,
default=2,
description="Indirect")
exposure: bpy.props.IntProperty(name="exposure",
default=-4,
description="Output exposure")
zoneMin: bpy.props.FloatVectorProperty(
name="zoneMin",
description="Radiance Min Zone Size",
subtype="XYZ",
default=(0.0, 0.0, 0.0))
zoneMax: bpy.props.FloatVectorProperty(
name="zoneMax",
description="Radiance Max Zone Size",
subtype="XYZ",
default=(0.0, 0.0, 0.0))
imagesize: bpy.props.IntProperty(
name="imagesize",
min=1,
default=768,
description="Resolution along longest dimension")
def drawButtons(self, layout):
split = layout.split()
split.column().operator(
"scene.radianceops",
text="Write Case Files").command = "writeRadianceFiles"
split.column().operator("scene.radianceops",
text="Render Frame").command = "executeRifFile"
def draw(self, layout):
L = layout.box()
L.row().label(text="Radiance Output Options:")
split = L.split()
split.column().prop(self, "imagesize")
split.column().prop(self, "indirect")
split.column().prop(self, "exposure")
split = L.split()
col = split.column()
col.prop(self, "quality", expand=False)
col.prop(self, "variability", expand=False)
col = split.column()
col.prop(self, "detail", expand=False)
col.prop(self, "penumbras")
L = layout.box()
L.row().prop(self, "zoneType", expand=False)
L.row().prop(self, "zoneMin", text="zoneMin")
L.row().prop(self, "zoneMax", text="zoneMax")
def getRadOptions(self):
text = "\nRESOLUTION= %u\n" % (self.imagesize)
text += "\nQUALITY= %s\n" % (self.quality)
text += "DETAIL= %s\n" % (self.detail)
text += "VARIABILITY= %s\n" % (self.variability)
text += "PENUMBRAS= %s\n" % (str(self.penumbras))
text += "INDIRECT= %u\n" % (self.indirect)
zmin = self.zoneMin
zmax = self.zoneMax
zsize = zmax - zmin
if zsize.length > 0.01:
text += "\nZONE= %s %f %f %f %f %f %f\n" % (
self.zoneType, zmin[0], zmax[0], zmin[1], zmax[1], zmin[2],
zmax[2])
if self.zoneType == "Exterior":
text += "EXPOSURE= %u\n" % (self.exposure)
else:
text += "EXPOSURE= %u\n" % (self.exposure)
text += "\nUP= Z\n"
text += "\nrender= \n"
return text
class BM_SCENE_ODS(bpy.types.PropertyGroup):
mainMenu: bpy.props.EnumProperty(
name="mainMenu",
items=makeTuples(["SunPath", "CFD", "Radiance", "Energy"]),
description="Procedural Compute menu categories")
class BM_OBJ_CFD(bpy.types.PropertyGroup):
mesh: bpy.props.PointerProperty(type=BM_OBJ_CFD_MESH)
bc_preset: bpy.props.StringProperty(name="Preset",
default='wall',
description="BC Preset")
bc_override_text: bpy.props.PointerProperty(
type=bpy.types.Text,
name="BC Override text",
description="Text that contains the override definition")
bc_overrides: bpy.props.StringProperty(name="BC Overrides",
default='',
description="BC Overrides")
##################################
items_list = makeTuples([
"wall", "wallSlip", "fixedPressure", "fixedPressureOutOnly",
"fixedVelocity", "custom"
])
preset: bpy.props.EnumProperty(name="preset",
items=items_list,
description="Preset",
default="wall",
update=setFields)
doMesh: bpy.props.BoolProperty(name="doMesh",
default=True,
description="Include in Meshing")
fields: bpy.props.CollectionProperty(type=BM_OBJ_CFD_PATCHFIELD,
name="fields",
description="Fields")
active_fields_index: bpy.props.IntProperty()
porous_isPorous: bpy.props.BoolProperty(
name="isPorous", default=False, description="Is this object Porous")
porous_Dcoeff: bpy.props.IntVectorProperty(name="Dcoeff",
description="D",
default=(0, 0, 0))
porous_Fcoeff: bpy.props.FloatVectorProperty(name="Fcoeff",
description="F",
default=(3.5, 3.5, 3.5))
# Fcoeff is the Forchheimer coeffcients which relate to the v^2 component of the Darcy-Forchheimer law
# F = 2*K/(rho*dx) where K is the pressure loss coefficient & dx is the distance over which that pressure is lost
# using values of dx=0.25, rho=1.2 & K=0.5 gives F = 3.33 rounded up to 3.5
# Dcoeff is the Darcy component that relates to v
source_isSource: bpy.props.BoolProperty(
name="isSource",
default=False,
description="Is this object a scalar Source")
items_list = makeTuples(["absolute", "specific"])
source_volMode: bpy.props.EnumProperty(
name="volMode",
items=items_list,
description="Volume Mode (specific = amount/m3)",
default="specific")
source_expRate: bpy.props.FloatProperty(name="expRate",
description="Explicit Rate",
default=1.0)
source_impRate: bpy.props.FloatProperty(name="impRate",
description="Implicit Rate",
default=0.0)
def drawMenu(self, layout):
L = layout.box()
self.mesh.drawMenu(L)
L = layout.box()
L.row().label(text="Boundary Conditions:")
L.row().prop(self, "bc_preset")
if not self.bc_overrides.strip():
L.row().prop(self, "bc_override_text")
if not self.bc_override_text:
L.row().prop(self, "bc_overrides")
L.row().operator("scene.cfdoperators",
text="Copy to Selected").command = "copy_bcs"
'''
L.row().prop(self, "preset", expand=False)
sc = bpy.context.scene
if 'porous' in sc.ODS_CFD.solver.name:
L.row().prop(self, "porous_isPorous")
if self.porous_isPorous:
L.row().prop(self, "porous_Dcoeff", expand=True)
L.row().prop(self, "porous_Fcoeff", expand=True)
return None
if 'scalarSource' in sc.ODS_CFD.solver.name:
L.row().prop(self, "source_isSource")
if self.source_isSource:
split = L.split()
split.column().prop(self, "source_volMode", expand=False)
split.column().prop(self, "source_expRate", expand=False)
split.column().prop(self, "source_impRate", expand=False)
return None
if self.preset == 'custom':
drawCollectionTemplateList(L, self, "fields")
if self.active_fields_index >= 0:
self.fields[self.active_fields_index].draw(L)
else:
values = getSolver().presets[self.preset]
fields = getSolver().fields()
if 'draw' not in values:
return None
drawFields = values['draw']
for f in drawFields:
if f in self.fields:
self.fields[f].draw(L.box(), header=True)
else:
row = L.box().row()
row.label(text = "%s = %s"%(f, values[f]))
'''
return None
def addField(self, fieldName, classType):
if fieldName in self.fields:
return self.fields[fieldName]
newField = self.fields.add()
newField.name = fieldName
newField.classType = classType
return newField
def setField(self, fieldName, patchType, value, var='value'):
f = self.fields[fieldName]
f.setPatchType(patchType)
f.setValue(value, var=var)
return f
def delField(self, fieldName):
return self.fields.remove(self.fields.find(fieldName))
def getText(self, field):
if field in self.fields:
text = self.fields[field].getText()
else:
f = getSolver().patchFields('wall')[field]
self.addField(field, f['classType'])
self.setField(field, f['patchType'], f['default'])
text = self.fields[field].getText()
self.delField(field)
return text
def to_json(self):
""" Boundary condition overrides may be provided in OpenFOAM dictionary
format OR JSON and may either be defined in-line or as a reference to
a Blender Text that contains the
"""
overrides = ""
if self.bc_override_text:
overrides = self.bc_override_text.as_string()
else:
overrides = self.bc_overrides.strip()
# To to parse the string as JSON
try:
overrides = json.loads(overrides)
except json.JSONDecodeError:
pass
# Return the dictionary
json_dict = {"preset": self.bc_preset, "overrides": overrides}
return json_dict
class BM_SCENE_CFDSolver(bpy.types.PropertyGroup):
RAS: bpy.props.PointerProperty(type=BM_SCENE_CFDSolver_RAS)
LES: bpy.props.PointerProperty(type=BM_SCENE_CFDSolver_LES)
items_list = makeTuples([
"potentialFoam",
"simpleFoam",
"pisoFoam",
"buoyantSimpleFoam",
"buoyantPimpleFoam",
"buoyantBoussinesqSimpleFoam",
"buoyantBoussinesqPimpleFoam"
])
name: bpy.props.EnumProperty(name="solver", items=items_list, description="Solver Name", default="simpleFoam")
items_list = makeTuples(["Laminar", "RAS"])
turbModel: bpy.props.EnumProperty(name="turbModel", items=items_list, description="Turbulence Model", default="RAS")
nu: bpy.props.FloatProperty(name="nu", step=1, precision=5, description="Kinematic Viscosity (nu)", default=1.5e-5)
fields: bpy.props.CollectionProperty(type=ODS_CFD_FIELDS, name="fields", description="Fields")
active_fields_index: bpy.props.IntProperty()
# Define the overrides here (as pointers to Blender text blocks)
override_setup: bpy.props.PointerProperty(type=bpy.types.Text, name="Setup overrides", description="Reference to a a text that contains setup override")
override_fields: bpy.props.PointerProperty(type=bpy.types.Text, name="Fields overrides", description="Reference to a a text that contains fields override")
override_presets: bpy.props.PointerProperty(type=bpy.types.Text, name="Presets overrides", description="Reference to a text that contains preset overrides")
override_case_files: bpy.props.PointerProperty(type=bpy.types.Text, name="Case file overrides", description="Reference to a text that contains case file overrides")
def drawMenu(self, layout):
sc = bpy.context.scene
# Draw Solver name and tubulence model selections
L = layout.box()
L.row().prop(self, "name", expand=False)
if not self.name == "potentialFoam":
L.row().prop(self, "turbModel")
if self.turbModel == "Laminar":
return
m = getattr(self, self.turbModel)
m.drawMenu(L)
L = layout.box()
L.label(text="Overrides:")
L.row().prop(self, "override_setup")
L.row().prop(self, "override_fields")
L.row().prop(self, "override_presets")
L.row().prop(self, "override_case_files")
# Draw Internal fields and defaults
#L = layout.box()
#L.label(text="Fields and Defaults")
#drawCollectionTemplateList(L, self, "fields")
#if len(self.fields) > 0 and self.active_fields_index >= 0:
# self.fields[self.active_fields_index].draw(L)
def to_json(self):
objects = bpy.context.visible_objects
skip_names = ['cfdBoundingBox','cfdMeshKeepPoint']
bcs = {
formatObjectName(obj.name): obj.ODS_CFD.to_json()
for obj in objects if not obj.name in skip_names
}
json_dict = {
'solver': self.name,
'boundary_conditions': bcs,
'overrides': {
'setup': [self.override_setup.as_string()] if self.override_setup else [],
'presets': [self.override_presets.as_string()] if self.override_presets else [],
'fields': [self.override_fields.as_string()] if self.override_fields else [],
'caseFiles': [self.override_case_files.as_string()] if self.override_case_files else []
}
}
return json_dict
class imageprops(bpy.types.PropertyGroup):
ndivs: bpy.props.IntProperty(
name="n", description="Number of contours(=legend values)", default=8)
decades: bpy.props.IntProperty(name="log",
description="Log scaling factor",
default=1)
mult: bpy.props.FloatProperty(name="m",
description="Multiplication factor",
default=179)
scale: bpy.props.FloatProperty(name="s",
description="Scale factor (0=auto)",
default=0)
label: bpy.props.StringProperty(name="label",
description="Label",
maxlen=10,
default="lux")
legwidth: bpy.props.IntProperty(name="lw",
description="Legend Width",
default=100)
legheight: bpy.props.IntProperty(name="lh",
description="Legend Height",
default=200)
exposure: bpy.props.IntProperty(name="exposure",
default=-4,
description="Output exposure")
overlaypic: bpy.props.StringProperty(name="picture",
description="Overlay Picture",
maxlen=248,
default="",
subtype='FILE_PATH')
output: bpy.props.StringProperty(name="output",
description="Output",
maxlen=248,
default="out.hdr",
subtype='FILE_PATH')
items_list = makeTuples(["None", "Lines", "Bands"])
contours: bpy.props.EnumProperty(name="contours",
items=items_list,
default="None")
limit: bpy.props.FloatProperty(name="lim",
description="Threshold limit value",
default=500)
def draw(self, layout):
row = layout.row()
row.prop(self, "ndivs")
row.prop(self, "decades")
row = layout.row()
row.prop(self, "legwidth")
row.prop(self, "legheight")
layout.row().prop(self, "contours")
layout.row().prop(self, "overlaypic")
row = layout.row()
row.prop(self, "mult")
row.operator("image.falsecolor", text="getDF").command = "getDFMult"
layout.row().prop(self, "scale")
layout.row().prop(self, "label")
layout.row().prop(self, "output")
row = layout.row()
row.operator("image.falsecolor", text="Make").command = "falsecolor"
row.operator("image.falsecolor", text="Reload").command = "load"
def drawBatch(self, layout):
row = layout.row()
row.prop(self, "mult")
row.prop(self, "limit")
row = layout.row()
row.operator("scene.batchstats", text="Batch Stats")
return
def drawThreshold(self, layout):
row = layout.row()
row.prop(self, "mult")
row.prop(self, "limit")
layout.row().prop(self, "exposure")
layout.row().prop(self, "output")
layout.row().operator("image.falsecolor",
text="Calculate").command = "threshold"
def getRadOptions(self):
return ""
class BM_SCENE_CFDSystem(bpy.types.PropertyGroup):
# Server login and token properties
host: bpy.props.StringProperty(name="Host",
default='https://compute.procedural.build',
description="Compute host server")
username: bpy.props.StringProperty(name="Username",
default='',
description="Compute username")
password: bpy.props.StringProperty(name="Password",
default='',
description="Compute password")
access_token: bpy.props.StringProperty(name="Access Token",
default='',
description="Access Token")
refresh_token: bpy.props.StringProperty(name="Refresh Token",
default='',
description="Refresh Token")
expire_time: bpy.props.StringProperty(
name="Expires in", default='', description="Token expires in seconds")
# Project and task name
project_name: bpy.props.StringProperty(name="Project Name",
default='',
description="Project name")
project_number: bpy.props.StringProperty(
name="Project Number",
default='',
description="Project number (optional)")
project_id: bpy.props.StringProperty(name="Project ID",
default='',
description="Project ID")
project_data: bpy.props.StringProperty(name="Project data",
default='',
description="Project data")
task_name: bpy.props.StringProperty(name="Task Name",
default='',
description="Task name")
task_id: bpy.props.StringProperty(name="Task ID",
default='',
description="Task ID")
task_data: bpy.props.StringProperty(name="Task data",
default='',
description="Task data")
# Legacy system settings from ODS Studio
runMPI: bpy.props.BoolProperty(name="runMPI",
description="Do MPIRun",
default=False)
items_list = makeTuples(["simple", "hierarchical"])
decompMethod: bpy.props.EnumProperty(name="decompMethod",
items=items_list,
description="Decomposition Method",
default="hierarchical")
numSubdomains: bpy.props.IntProperty(
name="SubDomains",
min=1,
description="Number of SubDomains for Parallel Processing")
decompN: bpy.props.IntVectorProperty(name="Nxyz",
description="Splits in XYZ",
default=(1, 1, 1),
min=1)
decompDelta: bpy.props.FloatProperty(
name="Delta",
step=1,
precision=3,
default=0.001,
description="delta value for MPI decomposition")
decompOrder: bpy.props.StringProperty(name="Order",
default='xyz',
description="Order of decomposition")
caseDir: bpy.props.StringProperty(name="caseDir",
default="//foam",
maxlen=128,
description="Case Directory",
subtype='FILE_PATH')
machines: bpy.props.StringProperty(
name="Machines",
default="localhost",
description="Machines for MPIrun (comma separated)")
if 'Windows' in bpy.app.build_platform.decode():
homedir: bpy.props.StringProperty(
name="OFHomeDir",
default="C:/OpenFOAM",
maxlen=128,
description="OpenFOAM Home Directory")
mpiOptions: bpy.props.StringProperty(
name="mpiOptions",
default="-genvlist Path,WM_PROJECT_DIR,MPI_BUFFER_SIZE",
description="Added options for mpi")
else:
homedir: bpy.props.StringProperty(
name="OFHomeDir",
default="/opt/openfoam211",
maxlen=128,
description="OpenFOAM Home Directory")
mpiOptions: bpy.props.StringProperty(
name="mpiOptions", default="", description="Added options for mpi")
def drawMenu(self, layout):
sc = bpy.context.scene
L = layout.box()
L.row().label(text="Authentication")
L.row().prop(self, "host")
L.row().prop(self, "username")
L.row().prop(self, "password")
split = L.split()
col = split.column()
col.operator("scene.compute_cfdoperators",
text="Login").command = "login"
col = split.column()
col.operator("scene.compute_cfdoperators",
text="Refresh").command = "refresh"
row = L.row()
row.prop(self, "access_token", text="token")
row.enabled = False
row = L.row()
row.prop(self, "expire_time", text="expires in (s)")
row.enabled = False
L = layout.box()
L.row().label(text="Project/Task")
L.row().prop(self, "project_name")
row = L.row()
row.prop(self, "project_id")
row.enabled = False
L.row().prop(self, "task_name")
row = L.row()
row.prop(self, "task_id")
row.enabled = False
L.row().operator(
"scene.compute_cfdoperators",
text="Get or Create").command = "get_or_create_project_and_task"
L.row().prop(self, "decompN")