From 3b896fb3fce0b6f9d1eea1e9bd17e26bf0822682 Mon Sep 17 00:00:00 2001 From: L-Nafaryus Date: Sun, 10 Oct 2021 21:46:54 +0500 Subject: [PATCH] Mod: - --- anisotropy/core/cli.py | 3 + anisotropy/core/main.py | 20 +- anisotropy/core/models.py | 13 +- anisotropy/samples/bodyCentered.py | 24 ++ anisotropy/samples/faceCentered.py | 37 ++- anisotropy/samples/simple.py | 27 +- anisotropy/samples/structure.py | 9 +- playground/analytics.ipynb | 376 ++++++++++++++++++++--- playground/database.ipynb | 462 +++++++++++++++++++++++++++++ playground/geometry.ipynb | 164 ++++++++++ playground/mesh.py | 119 ++++++++ playground/test_anisotropy.toml | 281 ++++++++++++++++++ playground/test_db.db | Bin 0 -> 16384 bytes playground/test_mesh_2.py | 4 + playground/test_models.py | 87 ++++++ playground/test_smesh.py | 19 ++ 16 files changed, 1591 insertions(+), 54 deletions(-) create mode 100644 playground/database.ipynb create mode 100644 playground/geometry.ipynb create mode 100644 playground/mesh.py create mode 100644 playground/test_anisotropy.toml create mode 100644 playground/test_db.db create mode 100644 playground/test_models.py create mode 100644 playground/test_smesh.py diff --git a/anisotropy/core/cli.py b/anisotropy/core/cli.py index 7a2a3d7..711cc45 100644 --- a/anisotropy/core/cli.py +++ b/anisotropy/core/cli.py @@ -171,9 +171,12 @@ def update(force, params, path): if args.get("theta"): paramsAll = [ entry for entry in paramsAll if args["theta"] == entry["structure"]["theta"] ] + from anisotropy.core.models import Structure, Mesh + from numpy for entry in paramsAll: database.update(entry) + click.echo("{} entries was updated.".format(len(paramsAll))) else: diff --git a/anisotropy/core/main.py b/anisotropy/core/main.py index 39845e4..25aaf75 100644 --- a/anisotropy/core/main.py +++ b/anisotropy/core/main.py @@ -312,7 +312,25 @@ class Anisotropy(object): # Mesh ## logger.info("Prepairing mesh ...") - + + params = db.Mesh() + mesh = mesh.Mesh(shapeGeometry) + algo3d = mesh.algo3d(Netgen3D) + algo3d.apply(**params) + + mesh = smesh.Mesh(shape) + algo3d = mesh.Tetrahedron(algo = smeshBuilder.NETGEN_3D) + algo2d = mesh.Triangle(algo = smeshBuilder.NETGEN_2D) + hypo2d = algo2d.MaxElementArea(0.197375) + algo1d = mesh.Segment() + hypo1d = algo1d.AutomaticLength(1) + + algo2d = mesh.Triangle(algo = smeshBuilder.NETGEN_2D, geom = strips) + hypo2d = algo2d.LengthFromEdges() + algo1d = mesh.Segment(algo = smeshBuilder.COMPOSITE, geom = strips) + hypo1d = algo1d.AutomaticLength(0.633882) + hypo1d.SetFineness( 1 ) + mp = p["mesh"] lengths = [ diff --git a/anisotropy/core/models.py b/anisotropy/core/models.py index d09e90c..832ac1c 100644 --- a/anisotropy/core/models.py +++ b/anisotropy/core/models.py @@ -8,7 +8,7 @@ from peewee import ( AutoField, ForeignKeyField, TextField, FloatField, IntegerField, BooleanField, - TimeField + TimeField, DateTimeField ) import json @@ -51,6 +51,17 @@ class JSONField(TextField): return json.loads(value) +class Execution(Model): + execution_id = AutoField() + + date = DateTimeField() + executionTime = TimeField() + + class Meta: + database = db + db_table = "executions" + + class Structure(BaseModel): structure_id = AutoField() diff --git a/anisotropy/samples/bodyCentered.py b/anisotropy/samples/bodyCentered.py index fceabe0..daaa226 100644 --- a/anisotropy/samples/bodyCentered.py +++ b/anisotropy/samples/bodyCentered.py @@ -17,6 +17,30 @@ class BodyCentered(StructureGeometry): def L(self): return self.r0 * 4 / sqrt(3) + @property + def thetaMin(self): + return 0.01 + + @property + def thetaMax(self): + return 0.18 + + @property + def fillets(self): + if self.direction == [1.0, 1.0, 1.0]: + C1, C2 = 0.3, 0.2 + Cf = C1 + (C2 - C1) / (self.thetaMax - self.thetaMin) * (self.theta - self.thetaMin) + delta = 0.02 + + return delta - Cf * (self.radius - self.r0) + + else: + C1, C2 = 0.3, 0.2 + Cf = C1 + (C2 - C1) / (self.thetaMax - self.thetaMin) * (self.theta - self.thetaMin) + delta = 0.02 + + return delta - Cf * (self.radius - self.r0) + def build(self): ### # Pore Cell diff --git a/anisotropy/samples/faceCentered.py b/anisotropy/samples/faceCentered.py index e6782c7..6ed70d4 100644 --- a/anisotropy/samples/faceCentered.py +++ b/anisotropy/samples/faceCentered.py @@ -16,6 +16,41 @@ class FaceCentered(StructureGeometry): def L(self): return self.r0 * 4 / sqrt(2) + @property + def thetaMin(self): + return 0.01 + + @property + def thetaMax(self): + self.Cscale = 0.8 + return 0.13 + + @property + def fillets(self): + if self.direction == [1.0, 1.0, 1.0]: + #C1, C2 = 0.3, 0.2 + #Cscale = 0.9 #C1 + (C2 - C1) / (self.thetaMax - self.thetaMin) * (self.theta - self.thetaMin) + #delta = 0.thetaMin = 0.01 + thetaMax = 0.13 + + L = 1.0 + r0 = L * sqrt(2) / 4 + radius = r0 / (1 - structure["theta"]) + + C1, C2 = 0.3, 0.2 + Cf = C1 + (C2 - C1) / (thetaMax - thetaMin) * (structure["theta"] - thetaMin) + delta = 0.012 + fillets = delta - Cf * (radius - r0)012 + + return self.Cscale * (2 - 1 / (1 - self.theta)) * self.r0 #delta - Cf * (self.radius - self.r0) + + else: + C1, C2 = 0.3, 0.2 + Cf = C1 + (C2 - C1) / (self.thetaMax - self.thetaMin) * (self.theta - self.thetaMin) + delta = 0.012 + + return delta - Cf * (self.radius - self.r0) + def build(self): ### # Pore Cell @@ -204,4 +239,4 @@ class FaceCentered(StructureGeometry): shapeShell = self.geo.ExtractShapes(self.shape, self.geo.ShapeType["SHELL"], True)[0] self.groups.append(self.createGroup(self.shape, shapeShell, "strips", self.groups + [grainsOrigin])) - self.groups.append(self.geo.CutListOfGroups([groupAll], self.groups, theName = "wall")) \ No newline at end of file + self.groups.append(self.geo.CutListOfGroups([groupAll], self.groups, theName = "wall")) diff --git a/anisotropy/samples/simple.py b/anisotropy/samples/simple.py index 3788f69..9e3d074 100644 --- a/anisotropy/samples/simple.py +++ b/anisotropy/samples/simple.py @@ -15,6 +15,31 @@ class Simple(StructureGeometry): @property def L(self): return 2 * self.r0 + + @property + def thetaMin(self): + return 0.01 + + @property + def thetaMax(self): + return 0.28 + + @property + def fillets(self): + if self.direction == [1.0, 1.0, 1.0]: + C1, C2 = 0.8, 0.5 + Cf = C1 + (C2 - C1) / (self.thetaMax - self.thetaMin) * (self.theta - self.thetaMin) + delta = 0.2 + + return delta - Cf * (self.radius - self.r0) + + else: + C1, C2 = 0.8, 0.5 + Cf = C1 + (C2 - C1) / (self.thetaMax - self.thetaMin) * (self.theta - self.thetaMin) + delta = 0.2 + + return delta - Cf * (self.radius - self.r0) + def build(self): ### @@ -190,4 +215,4 @@ class Simple(StructureGeometry): shapeShell = self.geo.ExtractShapes(self.shape, self.geo.ShapeType["SHELL"], True)[0] self.groups.append(self.createGroup(self.shape, shapeShell, "strips", self.groups + [grainsOrigin])) - self.groups.append(self.geo.CutListOfGroups([groupAll], self.groups, theName = "wall")) \ No newline at end of file + self.groups.append(self.geo.CutListOfGroups([groupAll], self.groups, theName = "wall")) diff --git a/anisotropy/samples/structure.py b/anisotropy/samples/structure.py index e4058ea..85d14b8 100644 --- a/anisotropy/samples/structure.py +++ b/anisotropy/samples/structure.py @@ -9,11 +9,11 @@ class StructureGeometry(object): self, direction: list = None, theta: float = None, - r0: float = None, + r0: float = 1, #L: float = None, #radius: float = None, filletsEnabled: bool = False, - fillets: float = None, + #fillets: float = None, **kwargs ): """Constructor method. @@ -29,16 +29,13 @@ class StructureGeometry(object): :param filletsEnabled: Enable fillets beetween spheres. - - :param fillets: - Fillets radius. """ # Geometry parameters self.direction = direction self.theta = theta self.r0 = r0 self.filletsEnabled = filletsEnabled - self.fillets = fillets + #self.fillets = fillets # General attributes self.geo = geometry.getGeom() diff --git a/playground/analytics.ipynb b/playground/analytics.ipynb index 6bcd0d3..1f0c684 100644 --- a/playground/analytics.ipynb +++ b/playground/analytics.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "cbaf1c39-e423-47a3-a3ea-e78a528bc4c1", "metadata": {}, "outputs": [], @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "09b1bf83-6b42-4144-81a0-b57c661181b1", "metadata": {}, "outputs": [], @@ -32,7 +32,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "f341fbd4-797b-4d5d-8393-0f7cf2e67883", "metadata": {}, "outputs": [], @@ -53,7 +53,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "c2dbce30-d80a-4b78-b2a6-cf9c2075f5b5", "metadata": {}, "outputs": [], @@ -653,63 +653,351 @@ }, { "cell_type": "code", - "execution_count": 43, - "id": "90d3e556-9576-47fe-85d0-e43168886299", - "metadata": {}, - "outputs": [], - "source": [ - "general: list = db.loadGeneral()\n", - "dfe: list = [] #DataFrame()\n", - "\n", - "for entry in general:\n", - " structure: dict = entry[\"structure\"]\n", - " extended: dict = db.load(structure[\"type\"], structure[\"direction\"], structure[\"theta\"])\n", - " fields: list = extended.keys()\n", - " \n", - " for key in fields:\n", - " extended[key] = pandas.json_normalize(extended[key])\n", - " \n", - " dfe.append(extended)\n", - "\n", - "dfe: DataFrame = DataFrame(dfe)\n", - "dfe: Series = Series(\n", - " [ pandas.concat(dfe[field].to_list(), ignore_index = True) for field in dfe.keys() ],\n", - " dfe.keys()\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "id": "437d9432-206e-4d23-a5cb-d9958b65f68a", + "execution_count": 8, + "id": "e994037e-e266-444a-9ee3-80cccdf8386f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "structure structure_id type directi...\n", - "mesh mesh_id structure_id maxSize minSize...\n", - "submesh submesh_id mesh_id name maxSize m...\n", - "meshresult meshresult_id mesh_id surfaceArea vo...\n", - "flow flow_id structure_id sc...\n", - "flowapproximation flow_approximation_id flow_id pressure.b...\n", - "flowresult flowresult_id flow_id flowRate por...\n", - "dtype: object" + "" ] }, - "execution_count": 44, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fc = df.assign(direction = df[\"direction\"].astype(\"str\"))\n", + "fc = fc[\n", + " (fc[\"type\"] == \"faceCentered\") & (fc[\"direction\"] == \"[1.0, 1.0, 1.0]\")\n", + "]\n", + "seaborn.set_style('whitegrid')\n", + "seaborn.scatterplot(data = fc, x = \"theta\", y = \"fillets\", hue = \"meshStatus\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b541a36e-f3b2-4b50-bfc9-ec8958666053", + "metadata": {}, + "outputs": [], + "source": [ + "general: list = db.loadGeneral()\n", + "dfe: list = [] #DataFrame()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2d93a051-acab-448b-a7fd-5fe281cc323f", + "metadata": {}, + "outputs": [], + "source": [ + "def pandasify(listOfDicts):\n", + " dfe: list = []\n", + " \n", + " for entry in listOfDicts:\n", + " structure: dict = entry[\"structure\"]\n", + " extended: dict = db.load(structure[\"type\"], structure[\"direction\"], structure[\"theta\"])\n", + " fields: list = extended.keys()\n", + "\n", + " for key in fields:\n", + " extended[key] = pandas.json_normalize(extended[key])\n", + "\n", + " dfe.append(extended)\n", + "\n", + " dfe: DataFrame = DataFrame(dfe)\n", + " dfe: Series = Series(\n", + " [ pandas.concat(dfe[field].to_list(), ignore_index = True) for field in dfe.keys() ],\n", + " dfe.keys()\n", + " )\n", + " \n", + " return dfe" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "437d9432-206e-4d23-a5cb-d9958b65f68a", + "metadata": {}, + "outputs": [], + "source": [ + "from anisotropy.core.main import Anisotropy" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "756351e4-34b6-49d1-8cdb-29e3def4361d", + "metadata": {}, + "outputs": [], + "source": [ + "model = Anisotropy()\n", + "params = model.loadFromScratch(\"test_anisotropy.toml\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a6a7b464-045a-4d81-a7ad-eca75590179f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "171" + ] + }, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "dfe" + "len(params)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "cdbc661b-701f-475b-a72a-51b3bd2937ee", + "metadata": {}, + "outputs": [], + "source": [ + "dfparams = pandasify(params)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "73e04119-9f70-4e22-928b-caef022c365d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
structure_idtypedirectionthetar0LradiusfilletsEnabledfillets
01simple[1.0, 0.0, 0.0]0.011.02.01.010101True0.191919
12simple[1.0, 0.0, 0.0]0.021.02.01.020408True0.183900
23simple[1.0, 0.0, 0.0]0.031.02.01.030928True0.175945
34simple[1.0, 0.0, 0.0]0.041.02.01.041667True0.168056
45simple[1.0, 0.0, 0.0]0.051.02.01.052632True0.160234
..............................
7980simple[1.0, 1.0, 1.0]0.241.02.01.315789True0.028070
8081simple[1.0, 1.0, 1.0]0.251.02.01.333333True0.022222
8182simple[1.0, 1.0, 1.0]0.261.02.01.351351True0.016517
8283simple[1.0, 1.0, 1.0]0.271.02.01.369863True0.010959
8384simple[1.0, 1.0, 1.0]0.281.02.01.388889True0.005556
\n", + "

84 rows × 9 columns

\n", + "
" + ], + "text/plain": [ + " structure_id type direction theta r0 L radius \\\n", + "0 1 simple [1.0, 0.0, 0.0] 0.01 1.0 2.0 1.010101 \n", + "1 2 simple [1.0, 0.0, 0.0] 0.02 1.0 2.0 1.020408 \n", + "2 3 simple [1.0, 0.0, 0.0] 0.03 1.0 2.0 1.030928 \n", + "3 4 simple [1.0, 0.0, 0.0] 0.04 1.0 2.0 1.041667 \n", + "4 5 simple [1.0, 0.0, 0.0] 0.05 1.0 2.0 1.052632 \n", + ".. ... ... ... ... ... ... ... \n", + "79 80 simple [1.0, 1.0, 1.0] 0.24 1.0 2.0 1.315789 \n", + "80 81 simple [1.0, 1.0, 1.0] 0.25 1.0 2.0 1.333333 \n", + "81 82 simple [1.0, 1.0, 1.0] 0.26 1.0 2.0 1.351351 \n", + "82 83 simple [1.0, 1.0, 1.0] 0.27 1.0 2.0 1.369863 \n", + "83 84 simple [1.0, 1.0, 1.0] 0.28 1.0 2.0 1.388889 \n", + "\n", + " filletsEnabled fillets \n", + "0 True 0.191919 \n", + "1 True 0.183900 \n", + "2 True 0.175945 \n", + "3 True 0.168056 \n", + "4 True 0.160234 \n", + ".. ... ... \n", + "79 True 0.028070 \n", + "80 True 0.022222 \n", + "81 True 0.016517 \n", + "82 True 0.010959 \n", + "83 True 0.005556 \n", + "\n", + "[84 rows x 9 columns]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dfparams.structure[dfparams.structure.type == \"simple\"]" ] }, { "cell_type": "code", "execution_count": null, - "id": "756351e4-34b6-49d1-8cdb-29e3def4361d", + "id": "c7abc63e-960c-4157-99b3-d947acf10c10", "metadata": {}, "outputs": [], "source": [] diff --git a/playground/database.ipynb b/playground/database.ipynb new file mode 100644 index 0000000..50dd7ec --- /dev/null +++ b/playground/database.ipynb @@ -0,0 +1,462 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "c4317e7e-d7b9-4bec-9cad-e26a377458b8", + "metadata": {}, + "outputs": [], + "source": [ + "from peewee import (\n", + " SqliteDatabase, JOIN, \n", + " Model, Field, \n", + " AutoField, ForeignKeyField, \n", + " TextField, FloatField, \n", + " IntegerField, BooleanField, \n", + " TimeField\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "db03ea1b-e950-4f0b-8c4f-c137417981ca", + "metadata": {}, + "outputs": [], + "source": [ + "db = SqliteDatabase(\"test_db.db\", pragmas = { \"foreign_keys\" : 1, \"journal_mode\": \"wal\" })" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e904a64b-9108-414b-974b-2dbf96018cf5", + "metadata": {}, + "outputs": [], + "source": [ + "class ListField(Field):\n", + " field_type = \"list\"\n", + "\n", + " def db_value(self, value):\n", + " return str(value)\n", + "\n", + " def python_value(self, value):\n", + " pval = []\n", + "\n", + " for entry in value[1 : -1].split(\",\"):\n", + " try:\n", + " pval.append(float(entry))\n", + "\n", + " except:\n", + " pval.append(entry.strip().replace(\"'\", \"\"))\n", + "\n", + " return pval" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a6049589-dd33-4cfa-8434-1c00285c01e0", + "metadata": {}, + "outputs": [], + "source": [ + "class Structure(Model):\n", + " structure_id = AutoField()\n", + "\n", + " type = TextField()\n", + " direction = ListField()\n", + " theta = FloatField()\n", + "\n", + " r0 = FloatField(null = True)\n", + " L = FloatField(null = True)\n", + " radius = FloatField(null = True)\n", + "\n", + " filletsEnabled = BooleanField(null = True)\n", + " fillets = FloatField(null = True)\n", + " #path = TextField()\n", + " \n", + " class Meta:\n", + " database = db\n", + " db_table = \"structures\"\n", + "\n", + "\n", + "class Mesh(Model):\n", + " mesh_id = AutoField()\n", + " structure_id = ForeignKeyField(Structure, backref = \"meshes\")\n", + "\n", + " maxSize = FloatField(null = True) \n", + "\n", + " class Meta:\n", + " database = db\n", + " db_table = \"meshes\"\n", + " depends_on = Structure" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "77c8b505-8b72-4f41-9f6d-d0b4e44884ea", + "metadata": {}, + "outputs": [], + "source": [ + "db.create_tables([Structure, Mesh])" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "708acdf5-a604-44c1-8631-d274d0273c1b", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "62c1c0a0-74ae-43cc-bc75-1fbd353540ae", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s1 = Structure(type = \"simple\", direction = [1, 0, 0], theta = 0.01)\n", + "s1.save()\n", + "\n", + "m1 = Mesh(structure_id = s1, maxSize = 1e-2)\n", + "m1.save()\n", + "\n", + "#db.commit()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "0e03bc08-94ea-4680-8223-dbafc13dcfe7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s1.theta = 0.12\n", + "s1.save()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "a2f68e62-0324-4ec2-8113-47cf6e1dc5bd", + "metadata": {}, + "outputs": [], + "source": [ + "ss = numpy.array([\n", + " Structure(type = \"simple\", direction = [1, 0, 0], theta = 0.01),\n", + " Structure(type = \"simple\", direction = [1, 0, 0], theta = 0.02)\n", + "])" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "6683ea42-5fdc-4b33-b709-5ea31ae5567f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dtype('O')" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ss.dtype" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "83cc7bde-e003-4f2c-ab9b-f9e37634c374", + "metadata": {}, + "outputs": [], + "source": [ + "Structure.bulk_create(ss)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "962010a5-68b8-4711-a067-962677aa406d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 simple [1.0, 0.0, 0.0] 0.12\n", + "2 simple [1.0, 0.0, 0.0] 0.01\n", + "3 simple [1.0, 0.0, 0.0] 0.01\n", + "4 simple [1.0, 0.0, 0.0] 0.01\n", + "5 simple [1.0, 0.0, 0.0] 0.01\n", + "6 simple [1.0, 0.0, 0.0] 0.01\n", + "7 simple [1.0, 0.0, 0.0] 0.01\n", + "8 simple [1.0, 0.0, 0.0] 0.01\n", + "9 simple [1.0, 0.0, 0.0] 0.01\n", + "10 simple [1.0, 0.0, 0.0] 0.01\n", + "11 simple [1.0, 0.0, 0.0] 0.01\n", + "12 simple [1.0, 0.0, 0.0] 0.02\n" + ] + } + ], + "source": [ + "for row in Structure.select():\n", + " print(row.structure_id, row.type, row.direction, row.theta)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a5fc7787-7045-4bb1-a846-5fff8b21417c", + "metadata": {}, + "outputs": [], + "source": [ + "sel = Structure.select()[-1]\n", + "sel2 = sel.meshes.select()[-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "480edddc-478e-47ce-8678-490455badd35", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sel2" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "8286c287-f89d-40bd-8045-a854013915c2", + "metadata": {}, + "outputs": [], + "source": [ + "sel3 = Structure.select().dicts().get()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "180b07cb-6c10-4390-9f9c-07bf9f74f39e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'structure_id': 1,\n", + " 'type': 'simple',\n", + " 'direction': [1.0, 0.0, 0.0],\n", + " 'theta': 0.12,\n", + " 'r0': None,\n", + " 'L': None,\n", + " 'radius': None,\n", + " 'filletsEnabled': None,\n", + " 'fillets': None}" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sel3" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "dc2e8b67-67ea-477a-af94-dd1ceb1a2a24", + "metadata": {}, + "outputs": [], + "source": [ + "from anisotropy.core.main import Anisotropy\n", + "model = Anisotropy()\n", + "params_: list = model.loadFromScratch(\"test_anisotropy.toml\")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "e73c9863-e8d7-4ed5-a27e-0c733c3daeb6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "171" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(params_)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "f532c668-965a-4c7c-aaa9-23a9e308a455", + "metadata": {}, + "outputs": [], + "source": [ + "params = numpy.array(params_)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "6ad8131f-3e0f-43b9-ab41-b6e3e56a5245", + "metadata": {}, + "outputs": [], + "source": [ + "from pandas import Series" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "6111802f-9e5f-47de-a6ea-f54dd062ecba", + "metadata": {}, + "outputs": [], + "source": [ + "pparams = Series(params_)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "11f04e87-e2f1-4d22-be85-8b6967935c92", + "metadata": {}, + "outputs": [], + "source": [ + "test = numpy.array([], dtype = object)" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "e1a930c3-e591-41e3-8d76-8316f4b8bfac", + "metadata": {}, + "outputs": [], + "source": [ + "test += 1" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "075e261f-4387-49c3-9c40-292885cffcc6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mDocstring:\u001b[0m\n", + "a.fill(value)\n", + "\n", + "Fill the array with a scalar value.\n", + "\n", + "Parameters\n", + "----------\n", + "value : scalar\n", + " All elements of `a` will be assigned this value.\n", + "\n", + "Examples\n", + "--------\n", + ">>> a = np.array([1, 2])\n", + ">>> a.fill(0)\n", + ">>> a\n", + "array([0, 0])\n", + ">>> a = np.empty(2)\n", + ">>> a.fill(1)\n", + ">>> a\n", + "array([1., 1.])\n", + "\u001b[0;31mType:\u001b[0m builtin_function_or_method\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "?test.fill" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "448c99bf-2b6f-43de-92d3-dc1267e766d3", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/playground/geometry.ipynb b/playground/geometry.ipynb new file mode 100644 index 0000000..68eb32b --- /dev/null +++ b/playground/geometry.ipynb @@ -0,0 +1,164 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c94a76d4-15cb-4628-980e-644c24119b55", + "metadata": { + "tags": [] + }, + "source": [ + "# Geometry parameters\n", + "## Face centered structure\n", + "\n", + "\n", + "$ \\theta_{min} = 0.01 $\n", + "\n", + "$ \\theta_{max} = 0.13 $\n", + "\n", + "$ L = 1 $\n", + "\n", + "$ r_0 = L \\sqrt{2} / 4 $\n", + "\n", + "Spheres radius:\n", + "\n", + "$ r = r_0 / (1 - \\theta) $\n", + "\n", + "Fillets radius:\n", + "\n", + "$ C_1 = 0.3, C_2 = 0.2 $\n", + "\n", + "$ C_f = C_1 + (C_2 - C_1) (\\theta_{max} - \\theta_{min}) / (\\theta - \\theta_{min}) $\n", + "\n", + "$ \\delta = 0.012 $\n", + "\n", + "$ r_{fillets} = \\delta - C_f (r - r_0) $" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "60e986af-be50-46ac-b8e6-73e12b0175b9", + "metadata": {}, + "outputs": [], + "source": [ + "from numpy import arange, sqrt\n", + "\n", + "thetaMin = 0.01\n", + "thetaMax = 0.13\n", + "\n", + "theta = arange(thetaMin, thetaMax + 0.01, 0.01)\n", + "\n", + "r0 = 1\n", + "L = r0 * 4 / sqrt(2)\n", + "#L = 1.0\n", + "#r0 = L * sqrt(2) / 4\n", + "radius = r0 / (1 - theta)\n", + "\n", + "C1, C2 = 0.3, 0.2\n", + "Cf = C1 + (C2 - C1) / (thetaMax - thetaMin) * (theta - thetaMin)\n", + "delta = 0.012\n", + "fillets = 0.9 * (2 - 1 / (1 - theta)) * r0#Cf * (r0 - radius) #(radius - r0)" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "dfa331c2-a2b0-4c81-8113-91ba38c35c42", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn\n", + "\n", + "seaborn.set_style(\"whitegrid\")\n", + "seaborn.lineplot(\n", + " data = {\"theta\": theta, \"radius\": radius}, \n", + " x = \"theta\", y = \"radius\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "b1ef64d1-ba45-4079-bac6-cbc1468174db", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "seaborn.lineplot(\n", + " data = {\"theta\": theta, \"fillets\": fillets}, \n", + " x = \"theta\", y = \"fillets\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f587e6da-c921-4533-8077-260f122636da", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/playground/mesh.py b/playground/mesh.py new file mode 100644 index 0000000..8442b98 --- /dev/null +++ b/playground/mesh.py @@ -0,0 +1,119 @@ + +class MeshAlgorithm(object): + pass + +class Netgen3D(MeshAlgorithm): + def __init__(self, **kwargs): + self.key = smeshBuilder.NETGEN_3D + + def initialize(self, algo): + self.algo = algo + self.hypo = self.algo.Parameters() + + + @property + def minSize(self): + return self.hypo.GetMinSize() + + @minSize.setter + def minSize(self, value): + self.hypo.SetMinSize(value) + +class MEFISTO(MeshAlgorithm): + + +class Mesh(object): + def __init__(self, geom): + + self.smesh = smeshBuilder.New() + self.geom = geom + self.mesh = self.smesh.Mesh(self.geom.shape, self.geom.name) + + def algo3d(self, algo: MeshAlgorithm, type = "tetrahedron"): + smeshAlgo = self.mesh.__dict__.get(type.capitalize()) + self.meshAlgorithm3d = algo() + self.meshAlgorithm3d.initialize(smeshAlgo(algo = self.meshAlgorithm3d.key)) + self.mesh.AddHypothesis(self.meshAlgorithm3d.hypo) + + return self.meshAlgorithm3d + + def algo2d(self, algo: MeshAlgorithm, type = "triangle"): + smeshAlgo = self.mesh.__dict__.get(type.capitalize()) + self.meshAlgorithm2d = algo() + self.meshAlgorithm2d.initialize(smeshAlgo(algo = self.meshAlgorithm2d.key)) + self.mesh.AddHypothesis(self.meshAlgorithm2d.hypo) + + return self.meshAlgorithm2d + + def algo1d(self, algo: MeshAlgorithm, type = "segment"): + smeshAlgo = self.mesh.__dict__.get(type.capitalize()) + self.meshAlgorithm1d = algo() + self.meshAlgorithm1d.initialize(smeshAlgo(algo = self.meshAlgorithm1d.key)) + self.mesh.AddHypothesis(self.meshAlgorithm1d.hypo) + + return self.meshAlgorithm1d + + def createGroups(self, prefix = None): + prefix = prefix or "" + + for group in self.shape.groups: + name = group.GetName() + + if name: + name = prefix + name + self.mesh.GroupOnGeom(group, name, SMESH.FACE) + + def compute(self): + """Compute mesh. + """ + isDone = self.mesh.Compute() + out = "" + err = self.mesh.GetComputeErrors() + returncode = int(not isDone) + + return out, err, returncode + + def stats(self): + return { + "elements": self.mesh.NbElements(), + "edges": self.mesh.NbEdges(), + "faces": self.mesh.NbFaces(), + "volumes": self.mesh.NbVolumes(), + "tetrahedrons": self.mesh.NbTetras(), + "prisms": self.mesh.NbPrisms(), + "pyramids": self.mesh.NbPyramids() + } + + def export( + filename: str + ): + """Export a mesh. + + Supported formats: unv. + + :param filename: + Name of the file to store the given mesh in. + + :return: + Output, error messages and returncode + """ + out, err, returncode = "", "", 0 + ext = os.path.splitext(filename)[1][1: ] + + try: + if ext == "unv": + self.mesh.ExportUNV(self.mesh, filename) + + else: + raise NotImplementedError(f"{ ext } is not supported") + + except NotImplementedError as e: + err = e + returncode = 1 + + except Exception as e: + err = e.details.text + returncode = 1 + + return out, err, returncode + \ No newline at end of file diff --git a/playground/test_anisotropy.toml b/playground/test_anisotropy.toml new file mode 100644 index 0000000..223514c --- /dev/null +++ b/playground/test_anisotropy.toml @@ -0,0 +1,281 @@ +# -*- coding: utf-8 -*- +# This file is part of anisotropy. +# License: GNU GPL version 3, see the file "LICENSE" for details. + +[logger] +name = "anisotropy" +format = "[ %(levelname)s ] %(message)s" + +[base] +simple = true +bodyCentered = true +faceCentered = true + +[[structures]] + [structures.structure] + type = "simple" + # auto # from theta: list # theta: float + theta = [0.01, 0.28, 0.01] # [min, max, step] + # auto # from directions:list # direction: list + directions = [ + [1, 0, 0], + [0, 0, 1], + [1, 1, 1] + ] + + # r0 = + # L = + # radius = + + filletsEnabled = true + # auto # fillets: float + + [structures.mesh] + maxSize = 0.5 + minSize = 0.05 + + fineness = 5 + growthRate = 0.5 + nbSegPerEdge = 2 + nbSegPerRadius = 1 + + chordalErrorEnabled = true + chordalError = 0.25 + + secondOrder = false + optimize = true + quadAllowed = false + useSurfaceCurvature = true + fuseEdges = true + checkChartBoundary = false + + viscousLayers = false + thickness = [0.01, 0.005] # [min, max] # step is controlled by theta count + numberOfLayers = 1 + stretchFactor = 1 + isFacesToIgnore = true + facesToIgnore = ["inlet", "outlet"] + # auto # faces: list + extrusionMethod = "SURF_OFFSET_SMOOTH" + + [[structures.submesh]] + name = "strips" + maxSize = 0.5 + minSize = 0.05 + + fineness = 5 + growthRate = 0.2 + nbSegPerEdge = 2 + nbSegPerRadius = 3 + + chordalErrorEnabled = true + chordalError = 0.25 + + secondOrder = false + optimize = true + quadAllowed = false + useSurfaceCurvature = true + fuseEdges = true + checkChartBoundary = false + + [structures.flowapproximation] + transportProperties.nu = 1e-6 + + pressure.boundaryField.inlet = { type = "fixedValue", value = 1e-3 } + pressure.boundaryField.outlet = { type = "fixedValue", value = 0.0 } + + # multiplication velocity value with flow direction vector + velocity.boundaryField.inlet = { type = "fixedValue", value = 6e-5 } + velocity.boundaryField.outlet = { type = "zeroGradient", value = "None" } + + [structures.flow] + scale = [ 1e-5, 1e-5, 1e-5 ] + + transportProperties.nu = 1e-6 + + pressure.boundaryField.inlet = { type = "fixedValue", value = 1e-3 } + pressure.boundaryField.outlet = { type = "fixedValue", value = 0.0 } + + velocity.boundaryField.inlet = { type = "pressureInletVelocity", value = 0.0 } + velocity.boundaryField.outlet = { type = "zeroGradient", value = "None" } + + +[[structures]] + [structures.structure] + type = "bodyCentered" + # auto # from theta: list # theta: float + theta = [0.01, 0.17, 0.01] # [min, max, step] + # auto # from directions:list # direction: list + directions = [ + [1, 0, 0], + [0, 0, 1], + [1, 1, 1] + ] + + # r0 = + # L = + # radius = + + filletsEnabled = true + # auto # fillets: float + + [structures.mesh] + maxSize = 0.5 + minSize = 0.05 + + fineness = 5 + growthRate = 0.5 + nbSegPerEdge = 2 + nbSegPerRadius = 1 + + chordalErrorEnabled = true + chordalError = 0.25 + + secondOrder = false + optimize = true + quadAllowed = false + useSurfaceCurvature = true + fuseEdges = true + checkChartBoundary = false + + viscousLayers = false + thickness = [0.005, 0.0005] # [min, max] # step is controlled by theta count + numberOfLayers = 1 + stretchFactor = 1 + isFacesToIgnore = true + facesToIgnore = ["inlet", "outlet"] + # auto # faces: list + extrusionMethod = "SURF_OFFSET_SMOOTH" + + [[structures.submesh]] + name = "strips" + maxSize = 0.5 + minSize = 0.05 + + fineness = 5 + growthRate = 0.2 + nbSegPerEdge = 2 + nbSegPerRadius = 3 + + chordalErrorEnabled = true + chordalError = 0.25 + + secondOrder = false + optimize = true + quadAllowed = false + useSurfaceCurvature = true + fuseEdges = true + checkChartBoundary = false + + [structures.flowapproximation] + transportProperties.nu = 1e-6 + + pressure.boundaryField.inlet = { type = "fixedValue", value = 1e-3 } + pressure.boundaryField.outlet = { type = "fixedValue", value = 0.0 } + + # multiplication velocity value with direction vector + velocity.boundaryField.inlet = { type = "fixedValue", value = 6e-5 } + velocity.boundaryField.outlet = { type = "zeroGradient", value = "None" } + + [structures.flow] + scale = [ 1e-5, 1e-5, 1e-5 ] + + transportProperties.nu = 1e-6 + + pressure.boundaryField.inlet = { type = "fixedValue", value = 1e-3 } + pressure.boundaryField.outlet = { type = "fixedValue", value = 0.0 } + + velocity.boundaryField.inlet = { type = "pressureInletVelocity", value = 0.0 } + velocity.boundaryField.outlet = { type = "zeroGradient", value = "None" } + + +[[structures]] + [structures.structure] + type = "faceCentered" + # auto # from theta: list # theta: float + theta = [0.01, 0.12, 0.01] # [min, max, step] + # auto # from directions:list # direction: list + directions = [ + [1, 0, 0], + [0, 0, 1], + [1, 1, 1] + ] + + # r0 = + # L = + # radius = + + filletsEnabled = true + # auto # fillets: float + + [structures.mesh] + maxSize = 0.5 + minSize = 0.05 + + fineness = 5 + growthRate = 0.5 + nbSegPerEdge = 2 + nbSegPerRadius = 1 + + chordalErrorEnabled = true + chordalError = 0.25 + + secondOrder = false + optimize = true + quadAllowed = false + useSurfaceCurvature = true + fuseEdges = true + checkChartBoundary = false + + viscousLayers = false + thickness = [0.001, 0.0005] # [min, max] # step is controlled by theta count + numberOfLayers = 1 + stretchFactor = 1 + isFacesToIgnore = true + facesToIgnore = ["inlet", "outlet"] + # auto # faces: list + extrusionMethod = "SURF_OFFSET_SMOOTH" + + [[structures.submesh]] + name = "strips" + maxSize = 0.5 + minSize = 0.05 + + fineness = 5 + growthRate = 0.2 + nbSegPerEdge = 2 + nbSegPerRadius = 3 + + chordalErrorEnabled = true + chordalError = 0.25 + + secondOrder = false + optimize = true + quadAllowed = false + useSurfaceCurvature = true + fuseEdges = true + checkChartBoundary = false + + [structures.flowapproximation] + transportProperties.nu = 1e-6 + + pressure.boundaryField.inlet = { type = "fixedValue", value = 1e-3 } + pressure.boundaryField.outlet = { type = "fixedValue", value = 0.0 } + + # multiplication velocity value with direction vector + velocity.boundaryField.inlet = { type = "fixedValue", value = 6e-5 } + velocity.boundaryField.outlet = { type = "zeroGradient", value = "None" } + + [structures.flow] + scale = [ 1e-5, 1e-5, 1e-5 ] + + transportProperties.nu = 1e-6 + + pressure.boundaryField.inlet = { type = "fixedValue", value = 1e-3 } + pressure.boundaryField.outlet = { type = "fixedValue", value = 0.0 } + + velocity.boundaryField.inlet = { type = "pressureInletVelocity", value = 0.0 } + velocity.boundaryField.outlet = { type = "zeroGradient", value = "None" } + + + diff --git a/playground/test_db.db b/playground/test_db.db new file mode 100644 index 0000000000000000000000000000000000000000..65290e31c5f718f61d8734e6c36c81b918eb8184 GIT binary patch literal 16384 zcmeI2zi-n(6vzD|iIcYE7?6q=xMZSI#SifZKnZSD5fYjN3B*s=zSJiYyPVI^f&@aq z!i>bu9{?+2U}J%aiHQLrBoG4=6GCv;{BjzMH-ykT#m~Nb-+OoO z+8iHNb}E{t9K~2s6ir+iaSfU-9^!p<;P}H`Q}#D6?+^lg`nyv6Idf6mpaB6O00e*l z5C8%|00;m9An^AI*t#)$z*O%T)OX27mxSJ>kh93)5hItVD+frJsWhyGmW7vV$E`EC zJfSM%daXB1!ZO}hjz=iZ-QS}bv!eaJ+!IcE@5YV3sda9_1mT$KAs@A#noV ztuvRf_)da#PP<#%AMNgHWV;KUPH=rZY!s4a#M-t)DiOP8%l8+L)E0iZ`LRSDk2qH< zp3V5NAo5+CZN{fuqoET-Vb$IwY-}3$sB@(Ut)H?Vbyo?iw3 z5r>QX%2;L`cX5w!yGJfQ%nlA|R)fkV2p|Go_e&jV)D3yXzft z?$A6wD1H}?JiPIK>B+8}rRikJy}o2BT~bJwQh2jqdeMGO&Q}hsRqKl}4uo!{{1b_e#00KY&2mk>f00e*l5C8%|;Qt^{ zD(qI&-uH=Z2~8ate0|6#NeTmrX$Z--`Mqx5%q6)DGn?efnVBS4*3^?+8B86_G z65kNS`5(Pj(0B9=eMO(q2k}pUx9E)+f(8VD01yBIKmZ5;0U!VbfB+Bx0zd!={Cfnl hx~fhUq%Gv7%^T7hIcalQX|ow=GrF|8meJLM_6s+8*G~Wd literal 0 HcmV?d00001 diff --git a/playground/test_mesh_2.py b/playground/test_mesh_2.py index a21b33d..b6bcc79 100644 --- a/playground/test_mesh_2.py +++ b/playground/test_mesh_2.py @@ -550,6 +550,8 @@ NETGEN_3D_1 = Mesh_2.Tetrahedron() status = Mesh_2.RemoveHypothesis(NETGEN_3D_Parameters_1_1) isDone = Mesh_2.Compute() [ Group_1_2, inlet_2, Group_3_2, outlet_2, Group_5_2, symetry0_2, Group_7_2, symetry1_2, Group_9, symetry2_2, Group_11, symetry3_2, Group_13, Group_14, strips_2, Group_16, wall_2 ] = Mesh_2.GetGroups() + + Mesh_3 = smesh.Mesh(simple_1) status = Mesh_3.AddHypothesis(Automatic_Length_3) Regular_1D_4 = Mesh_3.Segment() @@ -573,10 +575,12 @@ symetry3_3 = Mesh_3.GroupOnGeom(symetry3_1,'symetry3',SMESH.FACE) strips_3 = Mesh_3.GroupOnGeom(strips_1,'strips',SMESH.FACE) #Group_16_1 = Mesh_3.GroupOnGeom(__NOT__Published__Object__,'',SMESH.FACE) wall_3 = Mesh_3.GroupOnGeom(wall_1,'wall',SMESH.FACE) + Regular_1D_5 = Mesh_3.Segment(geom=strips_1) status = Mesh_3.AddHypothesis(Automatic_Length_2,strips_1) NETGEN_2D_5 = Mesh_3.Triangle(algo=smeshBuilder.NETGEN_2D,geom=strips_1) status = Mesh_3.AddHypothesis(Length_From_Edges_4,strips_1) + [ Group_1_3, inlet_3, Group_3_3, outlet_3, Group_5_3, symetry0_3, Group_7_3, symetry1_3, Group_9_1, symetry2_3, Group_11_1, symetry3_3, Group_13_1, Group_14_1, strips_3, Group_16_1, wall_3 ] = Mesh_3.GetGroups() isDone = Mesh_3.Compute() [ Group_1_3, inlet_3, Group_3_3, outlet_3, Group_5_3, symetry0_3, Group_7_3, symetry1_3, Group_9_1, symetry2_3, Group_11_1, symetry3_3, Group_13_1, Group_14_1, strips_3, Group_16_1, wall_3 ] = Mesh_3.GetGroups() diff --git a/playground/test_models.py b/playground/test_models.py new file mode 100644 index 0000000..e3dac44 --- /dev/null +++ b/playground/test_models.py @@ -0,0 +1,87 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +from peewee import ( + SqliteDatabase, JOIN, + Model, Field, + AutoField, ForeignKeyField, + TextField, FloatField, + IntegerField, BooleanField, + TimeField +) + +db = SqliteDatabase("test_db.db", pragmas = { "foreign_keys" : 1, "journal_mode": "wal" }) + +class ListField(Field): + field_type = "list" + + def db_value(self, value): + return str(value) + + def python_value(self, value): + pval = [] + + for entry in value[1 : -1].split(","): + try: + pval.append(float(entry)) + + except: + pval.append(entry.strip().replace("'", "")) + + return pval + +class Structure(Model): + structure_id = AutoField() + + type = TextField() + direction = ListField() + theta = FloatField() + + r0 = FloatField(null = True) + L = FloatField(null = True) + radius = FloatField(null = True) + + filletsEnabled = BooleanField(null = True) + fillets = FloatField(null = True) + #path = TextField() + + class Meta: + database = db + db_table = "structures" + + +class Mesh(Model): + mesh_id = AutoField() + structure_id = ForeignKeyField(Structure, backref = "meshes") + + maxSize = FloatField(null = True) + minSize = FloatField(null = True) + + fineness = IntegerField(null = True) + growthRate = FloatField(null = True) + nbSegPerEdge = FloatField(null = True) + nbSegPerRadius = FloatField(null = True) + + chordalErrorEnabled = BooleanField(null = True) + chordalError = FloatField(null = True) + + secondOrder = BooleanField(null = True) + optimize = BooleanField(null = True) + quadAllowed = BooleanField(null = True) + useSurfaceCurvature = BooleanField(null = True) + fuseEdges = BooleanField(null = True) + checkChartBoundary = BooleanField(null = True) + + viscousLayers = BooleanField(null = True) + thickness = FloatField(null = True) + numberOfLayers = IntegerField(null = True) + stretchFactor = FloatField(null = True) + isFacesToIgnore = BooleanField(null = True) + facesToIgnore = ListField(null = True) + #faces = [] + extrusionMethod = TextField(null = True) + + class Meta: + database = db + db_table = "meshes" + depends_on = Structure diff --git a/playground/test_smesh.py b/playground/test_smesh.py new file mode 100644 index 0000000..e27e325 --- /dev/null +++ b/playground/test_smesh.py @@ -0,0 +1,19 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +from salome.smesh import smeshBuilder + +smesh = smeshBuilder.New() + +ALGOS = [ + smeshBuilder.NETGEN_1D2D3D, + smeshBuilder.NETGEN_3D, smeshBuilder.NETGEN_1D2D, + smeshBuilder.NETGEN_2D, + smeshBuilder.MEFISTO, # only 2d + smeshBuilder.REGULAR, smeshBuilder.COMPOSITE +] + +mesh = smesh.Mesh(SHAPE) + +algo = mesh.Tetrahedron(algo = ALGO) +