def render(cls, data): """ Returns the rendered string. """ moorings: dict = data["moorings"] if moorings["enabled"] == "false": return "" each_mooredfloatings_templates: list = list( map( lambda mkbound: get_template_text(cls.MOORINGS_MOORED_FLOATING) .format(**{"mkbound": mkbound}), moorings["moored_floatings"])) formatter: dict = { "savevtk_moorings": moorings["saveoptions"]["savevtk_moorings"], "savecsv_points": moorings["saveoptions"]["savecsv_points"], "savevtk_points": moorings["saveoptions"]["savevtk_points"], "each_mooredfloatings_template": LINE_END.join(each_mooredfloatings_templates), "moordyn_template": cls.get_moordyn_embedded_template(data) if moorings["configuration_method"] == MooringsConfigurationMethod.EMBEDDED else get_template_text( cls.MOORDYN_EXTERNAL_CONFIG).format(moorings["moordyn_xml"]) } return get_template_text(cls.MOORINGS_BASE).format(**formatter)
def get_useboxlimit_template(cls, iodata: dict) -> str: if iodata["useboxlimit_freecentre_enabled"] == "true": return get_template_text( cls.INOUT_USEBOXLIMITWITHFREECENTRE).format(**iodata) else: return get_template_text( cls.INOUT_USEBOXLIMITWITHOUTFREECENTRE).format(**iodata)
def render(cls, data, rz_type: str): """ Returns the rendered string. """ template = get_template_text(cls.RZONES_XML) rz_templates = { "RelaxationZoneRegular": cls.RZONE_REGULAR_XML, "RelaxationZoneIrregular": cls.RZONE_IRREGULAR_XML, "RelaxationZoneFile": cls.RZONE_FILE_XML, "RelaxationZoneUniform": cls.RZONE_UNIFORM_XML } rzone_formatter = {} if rz_type == "RelaxationZoneUniform": if data["relaxation_zone"]["use_velocity"] == "true": rzone_formatter["rzuniform_velocity"] = get_template_text( cls.RZONE_UNIFORM_VELOCITY_XML).format( data["relaxation_zone"]["velocity"]) else: rzone_formatter[ "rzuniform_velocity"] = cls.get_velocity_times_template( data["relaxation_zone"]["velocity_times"]) rzone_formatter.update(data["relaxation_zone"]) formatter = { "rzone": get_template_text(rz_templates[rz_type]).format(**rzone_formatter) } return template.format(**formatter)
def render(cls, data): """ Returns the rendered string. """ each_damping_template: list = [] for obj_name, dzone in data["damping_zones"].items(): fc_object = FreeCAD.ActiveDocument.getObject(obj_name) dzone.update({ "limitmin": [ fc_object.OutList[0].Start[0] / DIVIDER, fc_object.OutList[0].Start[1] / DIVIDER, fc_object.OutList[0].Start[2] / DIVIDER ], "limitmax": [ str(fc_object.OutList[0].End[0] / DIVIDER), str(fc_object.OutList[0].End[1] / DIVIDER), str(fc_object.OutList[0].End[2] / DIVIDER) ] }) each_damping_template.append(get_template_text(cls.DAMPING_EACH).format(**dzone)) formatter = { "each": LINE_END.join(each_damping_template) } return get_template_text(cls.DAMPING_BASE).format(**formatter)
def get_zsurf_param_template(cls, zone: dict) -> str: """ Returns the imposezsurf inner template. """ if zone["elevation_info"][ "elevation_type"] == InletOutletElevationType.FIXED: return get_template_text( cls.INOUT_ZSURF_FIXED).format(**zone["elevation_info"]) elif zone["elevation_info"][ "elevation_type"] == InletOutletElevationType.VARIABLE and zone[ "elevation_info"][ "zsurf_mode"] == InletOutletZSurfMode.FILE: return get_template_text( cls.INOUT_ZSURF_FILE).format(**zone["elevation_info"]) elif zone["elevation_info"][ "elevation_type"] == InletOutletElevationType.VARIABLE and zone[ "elevation_info"][ "zsurf_mode"] == InletOutletZSurfMode.TIMELIST: inout_zsurf_timelist_formatter = zone["elevation_info"] time_value_each = [] for zsurftimevalue in zone["elevation_info"]["zsurftimes"]: time_value_each.append( get_template_text( cls.INOUT_ZSURF_TIMELIST_TIMEVALUE_EACH).format( zsurftimevalue[0], zsurftimevalue[1])) inout_zsurf_timelist_formatter["timevalue_each"] = LINE_END.join( time_value_each) return get_template_text(cls.INOUT_ZSURF_TIMELIST).format( **inout_zsurf_timelist_formatter) elif zone["elevation_info"][ "elevation_type"] == InletOutletElevationType.AUTOMATIC: return get_template_text( cls.INOUT_ZSURF_AUTOMATIC).format(**zone["elevation_info"]) # TEXTO CO INTERIOR DO TAG IMPOSEZSURF return ""
def get_movement_template_list(cls, mk_based_prop: dict) -> str: """ Returns a rendered list of movements. """ counter: int = 1 each_movement_template: list = list() if mk_based_prop["mlayerpiston"]: formatter: dict = { "count": counter, "motions_list": get_template_text(cls.MOTION_NULL_TEMPLATE) } each_movement_template.append( get_template_text( cls.MOTION_EACH_MOVEMENT_LIST_XML).format(**formatter)) else: for mov in mk_based_prop["movements"]: formatter: dict = { "count": counter, "motions_list": cls.get_each_motion_template(mov, counter), } each_movement_template.append( get_template_text( cls.MOTION_EACH_MOVEMENT_LIST_XML).format(**formatter)) counter += len( mov["motion_list"]) if "motion_list" in mov.keys() else 1 return LINE_END.join(each_movement_template)
def render(cls, data): """ Returns the rendered string. """ each_objreal_template: list = list() for prop in data["mkbasedproperties"].values(): if not prop["movements"] and not prop["mlayerpiston"]: continue formatter: dict = { "ref": prop["mk"] - MKFLUID_LIMIT, "movements_list": cls.get_movement_template_list(prop) } each_objreal_template.append( get_template_text( cls.MOTION_EACH_BASE_XML).format(**formatter)) if not each_objreal_template: # There are no movements in the case. Do not bother rendering the <motion> tag. return "" formatter: dict = { "each_objreal": LINE_END.join(each_objreal_template) } return get_template_text(cls.MOTION_BASE_XML).format(**formatter)
def get_velocity_times_template(cls, times: list) -> str: """ Renders the velocity times template for a uniform relaxation zone. """ timevalues = LINE_END.join( map( lambda tv: get_template_text( cls.RZONE_UNIFORM_VELOCITYTIMES_EACH_XML).format( tv[0], tv[1]), times)) return get_template_text( cls.RZONE_UNIFORM_VELOCITYTIMES_XML).format(each=timevalues)
def get_awas_template(cls, awas: dict) -> str: """ Renders the <awas_zsurf> tag for a piston generator. """ awas["correction"]["correction_enabled"] = "" if awas["correction"][ "enabled"] == "true" else "_" awas["correction_template"] = get_template_text( cls.WAVEPADDLES_PISTON_AWAS_CORRECTION).format( **awas["correction"]) return get_template_text(cls.WAVEPADDLES_PISTON_AWAS).format(**awas)
def render(cls, data): """ Returns the rendered string. """ for x in data["mkbasedproperties"].values(): if not "bound_initials" in x: x["bound_initials"] = None suitable_mkbasedproperties = filter( lambda x: x["initials"] is not None or x["bound_initials"] is not None, data["mkbasedproperties"].values()) if not suitable_mkbasedproperties: return "" initials_templates = list() for mkbasedproperty in suitable_mkbasedproperties: initials = mkbasedproperty["initials"] if initials is not None: if initials["initials_type"] == InitialsType.UNIFORM: initials_templates.append( get_template_text(cls.UNIFORM_XML).format(**initials)) elif initials["initials_type"] == InitialsType.LINEAR: initials_templates.append( get_template_text(cls.LINEAR_XML).format(**initials)) elif initials["initials_type"] == InitialsType.PARABOLIC: initials_templates.append( get_template_text( cls.PARABOLIC_XML).format(**initials)) bound_initials = mkbasedproperty["bound_initials"] if bound_initials is not None: if bound_initials["initials_type"] == BoundInitialsType.SET: initials_templates.append( get_template_text( cls.SET_XML).format(**bound_initials)) elif bound_initials[ "initials_type"] == BoundInitialsType.PLANE: initials_templates.append( get_template_text( cls.PLANE_XML).format(**bound_initials)) elif bound_initials[ "initials_type"] == BoundInitialsType.SPHERE: initials_templates.append( get_template_text( cls.SPHERE_XML).format(**bound_initials)) elif bound_initials[ "initials_type"] == BoundInitialsType.CYLINDER: initials_templates.append( get_template_text( cls.CYLINDER_XML).format(**bound_initials)) elif bound_initials[ "initials_type"] == BoundInitialsType.PARTS: initials_templates.append( get_template_text( cls.PARTS_XML).format(**bound_initials)) return get_template_text(cls.BASE_XML).format( initials_each=LINE_END.join(initials_templates))
def get_special_motion_template(cls, motion_generator: dict) -> str: """ Renders an SpecialMovement motion inside a movement. """ if not motion_generator: raise ValueError( "Generator for an SpecialMovement should always have a value") if motion_generator[ "type"] not in cls.MOTION_GENERATORS_TEMPLATES.keys(): return get_template_text(cls.MOTION_NULL_TEMPLATE) return get_template_text( cls.MOTION_GENERATORS_TEMPLATES[motion_generator["type"]]).format( **motion_generator)
def render(cls, data): """ Returns the rendered string. """ if data["acceleration_input"]["enabled"] == "false": return "" accinput_template_list: list = list() for accinput in data["acceleration_input"]["acclist"]: accinput["globalgravity_int"] = 1 if accinput["globalgravity"] else 0 accinput_template_list.append(get_template_text(cls.ACCINPUT_EACH).format(**accinput)) formatter: dict = { "each": LINE_END.join(accinput_template_list) } return get_template_text(cls.ACCINPUT_BASE).format(**formatter)
def get_bodies_template(cls, data) -> str: """ Returns a list of <body> tags for moordyn. """ each_body_template: list = list() for body in data["moorings"]["moordyn_configuration"]["bodies"]: each_body_template.append(get_template_text(cls.MOORDYN_BODY_COMPACT_TEMPLATE if body["depth"] == "false" else cls.MOORDYN_BODY_EXTENDED_TEMPLATE).format(**body)) return LINE_END.join(each_body_template)
def render(cls, data): """ Returns the rendered string. """ template = get_template_text(cls.INITIALS_XML) initials = map( lambda y: template.format(**y["initials"]), filter(lambda x: x["initials"] is not None, data["mkbasedproperties"].values())) return LINE_END.join(initials) if initials else ""
def generate_material(self, case) -> str: """ Returns a material XML definition for DualSPHysics from the data available on the given case. """ properties_list: list = list() for mkbasedproperty in case.mkbasedproperties.values(): if mkbasedproperty.property: properties_list.append( get_template_text(self.PROPERTY_MATERIALS_XML).format( **mkbasedproperty.property.__dict__))
def get_pointline_each_template(cls, chrono: dict) -> str: """ Renders the link_pointline part of the chrono template. """ link_pointline_each_templates: list = list() for link in chrono["link_pointline"]: link_pointline_each_templates.append( get_template_text(cls.POINTLINE_BASE).format(**link)) return LINE_END.join(link_pointline_each_templates)
def render(cls, data): """ Returns the rendered string. """ if not data["inlet_outlet"]["zones"]: return "" inout_zone_template_list: list = list() for zone in data["inlet_outlet"]["zones"]: each_formatter = zone each_formatter["zone"] = cls.get_zone_template(zone) each_formatter["imposevelocity_param"] = cls.get_imposevelocity_param_template(zone) each_formatter["zsurf_param"] = cls.get_zsurf_param_template(zone) inout_zone_template_list.append(get_template_text(cls.INOUT_EACH).format(**each_formatter)) formatter: dict = data["inlet_outlet"] formatter["each_zone"] = LINE_END.join(inout_zone_template_list) return get_template_text(cls.INOUT_BASE).format(**formatter)
def get_linearspring_each_template(cls, chrono: dict) -> str: """ Renders the link_linearspring part of the chrono template. """ link_linearspring_each_templates: list = list() for link in chrono["link_linearspring"]: link_linearspring_each_templates.append( get_template_text(cls.LINEARSPRING_BASE).format(**link)) return LINE_END.join(link_linearspring_each_templates)
def get_regular_piston_wave_template(cls, mk: int, generator: dict) -> str: """ Renders a <piston> tag from a regular piston wave generator. """ generator["mk"] = mk generator["awas_template"] = cls.get_awas_template( generator["awas"] ) if generator["awas"]["enabled"] == "true" else "" return get_template_text( cls.WAVEPADDLES_REGULAR_PISTON).format(**generator)
def generate(self, case) -> str: """ Returns the GenCase-compatible XML resulting from the case """ final_xml: str = get_template_text( self.BASE_XML).format(**self.get_adapted_case_data(case)) # Strip empty lines from the final XML to clean it up. while "\n\n" in final_xml: final_xml = final_xml.replace("\n\n", "\n") return final_xml
def get_specific_motion_template(cls, motion, first_index: int, index: int, is_last: bool, loops: bool): """ Renders an individual motion based on its type. """ if motion["type"] not in cls.MOTION_TEMPLATES.keys(): return get_template_text(cls.MOTION_NULL_TEMPLATE) motion.update({ "index": index, "next_attr": get_template_text(cls.MOTION_NEXT_ATTR).format(next_index=index + 1) }) if is_last: motion["next_attr"] = "" if not loops else get_template_text( cls.MOTION_NEXT_ATTR).format(next_index=first_index) return get_template_text( cls.MOTION_TEMPLATES[motion["type"]]).format(**motion)
def get_spheric_each_template(cls, chrono: dict) -> str: """ Renders the link_spheric part of the chrono template. """ link_spheric_each_templates: list = list() for link in chrono["link_spheric"]: formatter: dict = link formatter["idbody2_template"] = cls.get_spheric_idbody2_fragment( link) link_spheric_each_templates.append( get_template_text(cls.SPHERIC_BASE).format(**link)) return LINE_END.join(link_spheric_each_templates)
def get_objects_each_template(cls, chrono: dict) -> str: """ Renders the bodyfixed/floating part of the chrono template. """ object_each_template_list: list = list() for chrono_object in chrono["objects"]: formatter: dict = chrono_object formatter["modelnormal_template"] = cls.get_modelnormal_fragment( chrono_object) object_each_template_list.append( get_template_text(cls.OBJECTS_BASE).format(**formatter)) return LINE_END.join(object_each_template_list)
def render(cls, data): """ Returns the rendered string. """ periodicity_fragments: list = list() mode_3d: bool = data["mode3d"] == "true" if data["periodicity"]["x_periodicity"]["enabled"].lower() == "true": periodicity_fragments.append( get_template_text(cls.XINCY_XML).format( value=data["periodicity"]["x_periodicity"]["y_increment"] ) if mode_3d else "") periodicity_fragments.append( get_template_text(cls.XINCZ_XML).format( value=data["periodicity"]["x_periodicity"]["z_increment"])) if mode_3d and data["periodicity"]["y_periodicity"]["enabled"].lower( ) == "true": periodicity_fragments.append( get_template_text(cls.YINCX_XML).format( value=data["periodicity"]["y_periodicity"]["x_increment"])) periodicity_fragments.append( get_template_text(cls.YINCZ_XML).format( value=data["periodicity"]["y_periodicity"]["z_increment"])) if data["periodicity"]["z_periodicity"]["enabled"].lower() == "true": periodicity_fragments.append( get_template_text(cls.ZINCX_XML).format( value=data["periodicity"]["z_periodicity"]["x_increment"])) periodicity_fragments.append( get_template_text(cls.ZINCY_XML).format( value=data["periodicity"]["z_periodicity"]["y_increment"] ) if mode_3d else "") return LINE_END.join(periodicity_fragments)
def render(cls, data): """ Returns the rendered string. """ each_link_templates: list = list() for mkreal, mkbasedproperty in data["mkbasedproperties"].items(): if mkbasedproperty["property"]: each_formatter: dict = { "mkbound": mkreal - MKFLUID_LIMIT, "property_name": mkbasedproperty["property"]["name"], } each_link_templates.append( get_template_text( cls.EACH_LINK_XML).format(**each_formatter)) if not each_link_templates: return "" if data["execution_parameters"]["rigidalgorithm"] not in (2, 3): return "" formatter: dict = {"each_link": LINE_END.join(each_link_templates)} return get_template_text(cls.PROPERTIES_BASE).format(**formatter)
def get_moordyn_embedded_template(cls, data: dict) -> str: """ Returns the rendered embedded config for a moordyn configuration. """ moordyn = data["moorings"]["moordyn_configuration"] formatter: dict = { "endTime": data["execution_parameters"]["timemax"], "dtOut": data["execution_parameters"]["timeout"], "bodies_template": cls.get_bodies_template(data), "lines_template": cls.get_lines_template(data) } formatter.update(moordyn) return get_template_text(cls.MOORDYN_EMBEDDED_CONFIG).format(**formatter)
def get_lines_template(cls, data) -> str: """ Returns a list of <line> tags for moordyn. """ each_line_template: list = list() for line in data["moorings"]["moordyn_configuration"]["lines"]: line.update({ "vessel1_template": get_template_text(cls.MOORDYN_LINE_VESSEL_CONNECTION_TEMPLATE).format(**line["vessel_connection"]) if line["vessel_connection"] else "", "vessel2_template": get_template_text(cls.MOORDYN_LINE_VESSEL_CONNECTION_TEMPLATE).format(**line["vessel2_connection"]) if line["vessel2_connection"] else "", "fix_template": get_template_text(cls.MOORDYN_LINE_FIX_CONNECTION_TEMPLATE).format(**line["fix_connection"]) if line["fix_connection"] else "", "ea_template": get_template_text(cls.MOORDYN_LINE_EA_TEMPLATE).format(**line) if line["ea"] else "", "diameter_template": get_template_text(cls.MOORDYN_LINE_DIAMETER_TEMPLATE).format(**line) if line["diameter"] else "", "massDenInAir_template": get_template_text(cls.MOORDYN_LINE_MASSDENINAIR_TEMPLATE).format(**line) if line["massDenInAir"] else "", "ba_template": get_template_text(cls.MOORDYN_LINE_BA_TEMPLATE).format(**line) if line["ba"] else "", }) each_line_template.append(get_template_text(cls.MOORDYN_LINE_TEMPLATE).format(**line)) return LINE_END.join(each_line_template)
def render(cls, data): """ Returns the rendered string. """ if not data["inlet_outlet"]["zones"]: return "" inout_zone_template_list: list = list() for zone in data["inlet_outlet"]["zones"]: each_formatter = zone each_formatter["zoneinfo"] = cls.get_zone_template(zone) each_formatter[ "imposevelocity_param"] = cls.get_imposevelocity_param_template( zone) each_formatter["zsurf_param"] = cls.get_zsurf_param_template(zone) inout_zone_template_list.append( get_template_text(cls.INOUT_EACH).format(**each_formatter)) formatter: dict = data["inlet_outlet"] # 16/09/2021 Remove useboxlimit from the XML as Alex stated # formatter["useboxlimit_template"] = cls.get_useboxlimit_template(data["inlet_outlet"]) formatter["useboxlimit_template"] = "" formatter["each_zone"] = LINE_END.join(inout_zone_template_list) return get_template_text(cls.INOUT_BASE).format(**formatter)
def render(cls, data): """ Returns the rendered string. """ template = get_template_text(cls.DEFINITION_XML) fc_object = FreeCAD.ActiveDocument.getObject("Case_Limits") min_point = fc_object.Placement.Base formatter = { "dp": data["dp"], "pointmin": [min_point.x / DIVIDER, min_point.y / DIVIDER, min_point.z / DIVIDER], "pointmax": [ min_point.x / DIVIDER + fc_object.Length.Value / DIVIDER, min_point.y / DIVIDER + fc_object.Width.Value / DIVIDER if data["mode3d"] == "true" else min_point.y / DIVIDER, min_point.z / DIVIDER + fc_object.Height.Value / DIVIDER ] } return template.format(**formatter)
def render(cls, data): """ Returns the rendered string. """ suitable_mkbasedproperties = filter( lambda x: x["initials"] is not None, data["mkbasedproperties"].values()) if not suitable_mkbasedproperties: return "" initials_templates = list() for mkbasedproperty in suitable_mkbasedproperties: initials = mkbasedproperty["initials"] if initials["initials_type"] == InitialsType.UNIFORM: initials_templates.append( get_template_text(cls.UNIFORM_XML).format(**initials)) elif initials["initials_type"] == InitialsType.LINEAR: initials_templates.append( get_template_text(cls.LINEAR_XML).format(**initials)) elif initials["initials_type"] == InitialsType.PARABOLIC: initials_templates.append( get_template_text(cls.PARABOLIC_XML).format(**initials)) return LINE_END.join(initials_templates)