Archive CFD workflow 2026-10-12: _seiler_ref

.gitattributes

@@ -11422,13 +11422,4 @@ cfd_workflow_20261012/**/wallShearStress filter=lfs diff=lfs merge=lfs -text
 cfd_workflow_20261012/**/wallShearStressMean filter=lfs diff=lfs merge=lfs -text
 cfd_workflow_20261012/**/yPlus filter=lfs diff=lfs merge=lfs -text
 cfd_workflow_20261012/**/yPlusMean filter=lfs diff=lfs merge=lfs -text
-cfd_workflow_20261012/anchorgen_side60_20260923_v1/results/pair0342_source057/initial/prepared/constant/triSurface/car.stl filter=lfs diff=lfs merge=lfs -text
-cfd_workflow_20261012/anchorgen_side60_20260923_v1/results/pair0342_source057/target/prepared/constant/triSurface/car.stl filter=lfs diff=lfs merge=lfs -text
-cfd_workflow_20261012/anchorgen_side60_20260923_v1/results/pair0428_source071/final60/prepared/constant/triSurface/car.stl filter=lfs diff=lfs merge=lfs -text
-cfd_workflow_20261012/anchorgen_side60_20260923_v1/results/pair0428_source071/initial/prepared/constant/triSurface/car.stl filter=lfs diff=lfs merge=lfs -text
-cfd_workflow_20261012/anchorgen_side60_20260923_v1/results/pair0428_source071/target/prepared/constant/triSurface/car.stl filter=lfs diff=lfs merge=lfs -text
-cfd_workflow_20261012/anchorgen_side60_20260923_v1/results/pair0478_source079/final60/prepared/constant/triSurface/car.stl filter=lfs diff=lfs merge=lfs -text
-cfd_workflow_20261012/anchorgen_side60_20260923_v1/results/pair0478_source079/initial/prepared/constant/triSurface/car.stl filter=lfs diff=lfs merge=lfs -text
-cfd_workflow_20261012/anchorgen_side60_20260923_v1/results/pair0478_source079/target/prepared/constant/triSurface/car.stl filter=lfs diff=lfs merge=lfs -text
-cfd_workflow_20261012/anchorgen_side60_20260923_v1/results/pair0503_source083/final60/prepared/constant/triSurface/car.stl filter=lfs diff=lfs merge=lfs -text
-cfd_workflow_20261012/anchorgen_side60_20260923_v1/results/pair0503_source083/initial/prepared/constant/triSurface/car.stl filter=lfs diff=lfs merge=lfs -text
+cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/constant/triSurface/car.stl.ori filter=lfs diff=lfs merge=lfs -text

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/0/U

@@ -1,88 +1,3 @@
-/*--------------------------------*- C++ -*----------------------------------*\
-| =========                 |                                                 |
-| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  7                                     |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
-|    \\/     M anipulation  |                                                 |
-\*---------------------------------------------------------------------------*/
-FoamFile
-{
-    version     2.0;
-    format      ascii;
-    class       volVectorField;
-    object      U;
-}
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-dimensions [ 0 1 -1 0 0 0 0 ];
-internalField uniform (30 0.0 0.0);
-
-boundaryField
-{
-    #includeEtc "caseDicts/setConstraintTypes"
-    inlet
-    {
-
-        type fixedValue;
-        value uniform ( 30.0 0.0 0.0 );
-
-/*
-        type            uniformFixedValue;
-        uniformValue    table
-	(
-            (0 	 	(5 0 0))
-            //(20 	(10 0 0))
-            //(40 	(15 0 0))
-            //(60 	(20 0 0))
-            //(80 	(25 0 0))
-            (100 	(30 0 0))
-	);
-*/
-
-    }
-
-    outlet
-    {
-        //type zeroGradient;
-        //value uniform ( 0.0 0.0 0.0 );
-
-	type		inletOutlet;
-	inletValue	uniform (30 0 0);
-	value		uniform (30 0 0);
-    }
-
-    sides
-    {
-        type slip;
-    }
-
-    ground
-    {
-        type fixedValue;
-        value uniform ( 30.0 0.0 0.0 );
-
-/*
-        type            uniformFixedValue;
-        uniformValue    table
-	(
-            (0 	 	(5 0 0))
-            //(20 	(10 0 0))
-            //(40 	(15 0 0))
-            //(60 	(20 0 0))
-            //(80 	(25 0 0))
-            (100 	(30 0 0))
-	);
-*/
-    }
-
-    top
-    {
-        type slip;
-    }
-
-    car
-    {
-        type fixedValue;
-        value uniform ( 0 0 0);
-    }
-}
+version https://git-lfs.github.com/spec/v1
+oid sha256:562432c8ef08dd9d7a5c4aaa55e256f8c8c996c414fc0d50ac67bad22fb40f95
+size 1907

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/0/k

@@ -1,60 +1,3 @@
-/*--------------------------------*- C++ -*----------------------------------*\
-| =========                 |                                                 |
-| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  7                                     |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
-|    \\/     M anipulation  |                                                 |
-\*---------------------------------------------------------------------------*/
-FoamFile
-{
-    version     2.0;
-    format      ascii;
-    class       volScalarField;
-    object      k;
-}
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-dimensions [ 0 2 -2 0 0 0 0 ];
-internalField uniform 3.375;
-
-boundaryField
-{
-    #includeEtc "caseDicts/setConstraintTypes"
-    inlet
-    {
-        type fixedValue;
-        value uniform 3.375;
-    }
-
-    outlet
-    {
-        type zeroGradient;
-    }
-
-    sides
-    {
-        //type kqRWallFunction;
-        //value uniform 1e-20;
-        type slip;
-    }
-
-    ground
-    {
-        type kqRWallFunction;
-        value uniform 3.375;
-    }
-
-    top
-    {
-        //type kqRWallFunction;
-        //value uniform 1e-20;
-	type slip;
-    }
-
-    car
-    {
-        type kqRWallFunction;
-        value uniform 3.375;
-    }
-
-}
+version https://git-lfs.github.com/spec/v1
+oid sha256:b599768ea2ecec8b6d2f699ceea9336af32b3aba20826ec502df66fb0f175b7e
+size 1367

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/0/nut

@@ -1,59 +1,3 @@
-/*--------------------------------*- C++ -*----------------------------------*\
-| =========                 |                                                 |
-| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  7                                     |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
-|    \\/     M anipulation  |                                                 |
-\*---------------------------------------------------------------------------*/
-FoamFile
-{
-    version     2.0;
-    format      ascii;
-    class       volScalarField;
-    object      nut;
-}
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-dimensions [ 0 2 -1 0 0 0 0 ];
-internalField uniform 0.0001;
-
-boundaryField
-{
-    #includeEtc "caseDicts/setConstraintTypes"
-    inlet
-    {
-        type zeroGradient;
-    }
-
-    outlet
-    {
-        type zeroGradient;
-    }
-
-    sides
-    {
-        //type nutUSpaldingWallFunction;
-        //value uniform 0.001;
-        type slip;
-    }
-
-    ground
-    {
-        type nutUSpaldingWallFunction;
-        value uniform 0.0001;
-    }
-
-    top
-    {
-        //type nutUSpaldingWallFunction;
-        //value uniform 0.001;
-        type slip;
-    }
-
-    car
-    {
-        type nutUSpaldingWallFunction;
-        value uniform 0.0001;
-    }
-
-}
+version https://git-lfs.github.com/spec/v1
+oid sha256:e29a89f75f157ff99c42b2f5338511921f757a91452575b5b1dc7a2366f289f7
+size 1388

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/0/omega

@@ -1,62 +1,3 @@
-/*--------------------------------*- C++ -*----------------------------------*\
-| =========                 |                                                 |
-| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  7                                     |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
-|    \\/     M anipulation  |                                                 |
-\*---------------------------------------------------------------------------*/
-FoamFile
-{
-    version     2.0;
-    format      ascii;
-    class       volScalarField;
-    object      omega;
-}
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-dimensions [ 0 0 -1 0 0 0 0 ];
-internalField uniform 9000;
-
-boundaryField
-{
-    #includeEtc "caseDicts/setConstraintTypes"
-    inlet
-    {
-        type fixedValue;
-        value uniform 9000;
-    }
-
-    outlet
-    {
-        type zeroGradient;
-    }
-    
-    sides
-    {
-        //type omegaWallFunction;
-        //value uniform 1;
-        type slip;
-    }
-
-    ground
-    {
-        type omegaWallFunction;
-        //value uniform 9000;
-        value uniform 500000;
-    }
-
-    top
-    {
-        //type omegaWallFunction;
-        //value uniform 1;
-        type slip;
-    }
-
-    car
-    {
-        type omegaWallFunction;
-        //value uniform 9000;
-        value uniform 500000;
-    }
-
-}
+version https://git-lfs.github.com/spec/v1
+oid sha256:cbe61f8b4dd72db7cd569310c1810f959328b0797ecbbcc3469ea58b67e6798c
+size 1442

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/0/p

@@ -1,56 +1,3 @@
-/*--------------------------------*- C++ -*----------------------------------*\
-| =========                 |                                                 |
-| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  7                                     |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
-|    \\/     M anipulation  |                                                 |
-\*---------------------------------------------------------------------------*/
-FoamFile
-{
-    version     2.0;
-    format      ascii;
-    class       volScalarField;
-    object      p;
-}
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-dimensions [ 0 2 -2 0 0 0 0 ];
-internalField uniform 0.0;
-
-boundaryField
-{
-    #includeEtc "caseDicts/setConstraintTypes"
-    inlet
-    {
-        type zeroGradient;
-    }
-
-    outlet
-    {
-        type fixedValue;
-        value uniform 0.0;
-    }
-
-    sides
-    {
-        //type zeroGradient;
-        type slip;
-    }
-
-    ground
-    {
-        type zeroGradient;
-    }
-
-    top
-    {
-        //type zeroGradient;
-        type slip;
-    }
-
-    car
-    {
-        type zeroGradient;
-    }
-
-}
+version https://git-lfs.github.com/spec/v1
+oid sha256:b2c076ebfbd5801985fc179c56b02dafab1b1bc1043a9d5286aaf549b25a3088
+size 1238

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/0_org/U

@@ -1,88 +1,3 @@
-/*--------------------------------*- C++ -*----------------------------------*\
-| =========                 |                                                 |
-| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  7                                     |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
-|    \\/     M anipulation  |                                                 |
-\*---------------------------------------------------------------------------*/
-FoamFile
-{
-    version     2.0;
-    format      ascii;
-    class       volVectorField;
-    object      U;
-}
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-dimensions [ 0 1 -1 0 0 0 0 ];
-internalField uniform (30 0.0 0.0);
-
-boundaryField
-{
-    #includeEtc "caseDicts/setConstraintTypes"
-    inlet
-    {
-
-        type fixedValue;
-        value uniform ( 30.0 0.0 0.0 );
-
-/*
-        type            uniformFixedValue;
-        uniformValue    table
-	(
-            (0 	 	(5 0 0))
-            //(20 	(10 0 0))
-            //(40 	(15 0 0))
-            //(60 	(20 0 0))
-            //(80 	(25 0 0))
-            (100 	(30 0 0))
-	);
-*/
-
-    }
-
-    outlet
-    {
-        //type zeroGradient;
-        //value uniform ( 0.0 0.0 0.0 );
-
-	type		inletOutlet;
-	inletValue	uniform (30 0 0);
-	value		uniform (30 0 0);
-    }
-
-    sides
-    {
-        type slip;
-    }
-
-    ground
-    {
-        type fixedValue;
-        value uniform ( 30.0 0.0 0.0 );
-
-/*
-        type            uniformFixedValue;
-        uniformValue    table
-	(
-            (0 	 	(5 0 0))
-            //(20 	(10 0 0))
-            //(40 	(15 0 0))
-            //(60 	(20 0 0))
-            //(80 	(25 0 0))
-            (100 	(30 0 0))
-	);
-*/
-    }
-
-    top
-    {
-        type slip;
-    }
-
-    car
-    {
-        type fixedValue;
-        value uniform ( 0 0 0);
-    }
-}
+version https://git-lfs.github.com/spec/v1
+oid sha256:562432c8ef08dd9d7a5c4aaa55e256f8c8c996c414fc0d50ac67bad22fb40f95
+size 1907

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/0_org/k

@@ -1,60 +1,3 @@
-/*--------------------------------*- C++ -*----------------------------------*\
-| =========                 |                                                 |
-| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  7                                     |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
-|    \\/     M anipulation  |                                                 |
-\*---------------------------------------------------------------------------*/
-FoamFile
-{
-    version     2.0;
-    format      ascii;
-    class       volScalarField;
-    object      k;
-}
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-dimensions [ 0 2 -2 0 0 0 0 ];
-internalField uniform 3.375;
-
-boundaryField
-{
-    #includeEtc "caseDicts/setConstraintTypes"
-    inlet
-    {
-        type fixedValue;
-        value uniform 3.375;
-    }
-
-    outlet
-    {
-        type zeroGradient;
-    }
-
-    sides
-    {
-        //type kqRWallFunction;
-        //value uniform 1e-20;
-        type slip;
-    }
-
-    ground
-    {
-        type kqRWallFunction;
-        value uniform 3.375;
-    }
-
-    top
-    {
-        //type kqRWallFunction;
-        //value uniform 1e-20;
-	type slip;
-    }
-
-    car
-    {
-        type kqRWallFunction;
-        value uniform 3.375;
-    }
-
-}
+version https://git-lfs.github.com/spec/v1
+oid sha256:b599768ea2ecec8b6d2f699ceea9336af32b3aba20826ec502df66fb0f175b7e
+size 1367

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/0_org/nut

@@ -1,59 +1,3 @@
-/*--------------------------------*- C++ -*----------------------------------*\
-| =========                 |                                                 |
-| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  7                                     |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
-|    \\/     M anipulation  |                                                 |
-\*---------------------------------------------------------------------------*/
-FoamFile
-{
-    version     2.0;
-    format      ascii;
-    class       volScalarField;
-    object      nut;
-}
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-dimensions [ 0 2 -1 0 0 0 0 ];
-internalField uniform 0.0001;
-
-boundaryField
-{
-    #includeEtc "caseDicts/setConstraintTypes"
-    inlet
-    {
-        type zeroGradient;
-    }
-
-    outlet
-    {
-        type zeroGradient;
-    }
-
-    sides
-    {
-        //type nutUSpaldingWallFunction;
-        //value uniform 0.001;
-        type slip;
-    }
-
-    ground
-    {
-        type nutUSpaldingWallFunction;
-        value uniform 0.0001;
-    }
-
-    top
-    {
-        //type nutUSpaldingWallFunction;
-        //value uniform 0.001;
-        type slip;
-    }
-
-    car
-    {
-        type nutUSpaldingWallFunction;
-        value uniform 0.0001;
-    }
-
-}
+version https://git-lfs.github.com/spec/v1
+oid sha256:e29a89f75f157ff99c42b2f5338511921f757a91452575b5b1dc7a2366f289f7
+size 1388

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/0_org/omega

@@ -1,62 +1,3 @@
-/*--------------------------------*- C++ -*----------------------------------*\
-| =========                 |                                                 |
-| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  7                                     |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
-|    \\/     M anipulation  |                                                 |
-\*---------------------------------------------------------------------------*/
-FoamFile
-{
-    version     2.0;
-    format      ascii;
-    class       volScalarField;
-    object      omega;
-}
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-dimensions [ 0 0 -1 0 0 0 0 ];
-internalField uniform 9000;
-
-boundaryField
-{
-    #includeEtc "caseDicts/setConstraintTypes"
-    inlet
-    {
-        type fixedValue;
-        value uniform 9000;
-    }
-
-    outlet
-    {
-        type zeroGradient;
-    }
-    
-    sides
-    {
-        //type omegaWallFunction;
-        //value uniform 1;
-        type slip;
-    }
-
-    ground
-    {
-        type omegaWallFunction;
-        //value uniform 9000;
-        value uniform 500000;
-    }
-
-    top
-    {
-        //type omegaWallFunction;
-        //value uniform 1;
-        type slip;
-    }
-
-    car
-    {
-        type omegaWallFunction;
-        //value uniform 9000;
-        value uniform 500000;
-    }
-
-}
+version https://git-lfs.github.com/spec/v1
+oid sha256:cbe61f8b4dd72db7cd569310c1810f959328b0797ecbbcc3469ea58b67e6798c
+size 1442

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/0_org/p

@@ -1,55 +1,3 @@
-/*--------------------------------*- C++ -*----------------------------------*\
-| =========                 |                                                 |
-| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  7                                     |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
-|    \\/     M anipulation  |                                                 |
-\*---------------------------------------------------------------------------*/
-FoamFile
-{
-    version     2.0;
-    format      ascii;
-    class       volScalarField;
-    object      p;
-}
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-dimensions [ 0 2 -2 0 0 0 0 ];
-internalField uniform 0.0;
-
-boundaryField
-{
-    inlet
-    {
-        type zeroGradient;
-    }
-
-    outlet
-    {
-        type fixedValue;
-        value uniform 0.0;
-    }
-
-    sides
-    {
-        //type zeroGradient;
-        type slip;
-    }
-
-    ground
-    {
-        type zeroGradient;
-    }
-
-    top
-    {
-        //type zeroGradient;
-        type slip;
-    }
-
-    car
-    {
-        type zeroGradient;
-    }
-
-}
+version https://git-lfs.github.com/spec/v1
+oid sha256:a9933435039a1b90677edd393878dabf3c809b34703fb0fd42d30260c2c68999
+size 1191

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/constant/extendedFeatureEdgeMesh/car.extendedFeatureEdgeMesh

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:09a7e990bf7cd605eeec3173c7f4f94649a58498d99427c2e177de8850b27a57
+size 214444

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/constant/transportProperties

@@ -0,0 +1,20 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  7                                     |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      transportProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+transportModel Newtonian;
+
+nu nu [0 2 -1 0 0 0 0 ] 1.5881327800829875E-5;
+

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/constant/triSurface/car.stl.ori

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:75cee1fd8f57047f8d7879a10c62f84245c2b7855d00b0ab02ba1020ccecc743
+size 2193184

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/constant/turbulenceProperties

@@ -0,0 +1,24 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  7                                     |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      turbulenceProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+simulationType RAS;
+
+RAS
+{
+    RASModel kOmegaSST;
+    turbulence on;
+    printCoeffs on;
+}

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/forceCoeffs_car

@@ -0,0 +1,20 @@
+#set  yr [0:0.25]
+set term pngcairo
+set output "./images/forceCoeffs.png"
+#set  xr [0:3000]
+set  yr [0:2.0]
+set key bottom right
+set xlabel "Simulation time [s]"
+set ylabel "forceCoeff [-]"
+set title "Plot of forceCoeffs over simulationtime"
+set grid
+
+
+#plot 	"./postProcessing/car/0/forceCoeffs_0.dat" using ($1):($4) with lines title "lift_{coeff}",\
+	"./postProcessing/car/0/forceCoeffs_0.dat" using ($1):($3) with lines title "drag_{coeff}"
+
+plot 	"./postProcessing/car/0/forceCoeffs.dat" using ($1):($4) with lines title "lift_{coeff}",\
+	"./postProcessing/car/0/forceCoeffs.dat" using ($1):($3) with lines title "drag_{coeff}"
+
+#pause -1
+#reread 

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/forces

@@ -0,0 +1,18 @@
+#set  yr [0:0.25]
+set term pngcairo
+set output "./images/forces.png"
+#set  xr [0:2000]
+set  yr [0:500]
+set key bottom right
+set xlabel "Simulation time [s]"
+set ylabel "forces [N]"
+set title "Plot of forces over simulationtime"
+set grid
+
+#plot 	"./postProcessing/forces/0/forces_0.dat" using ($1):($4) with lines title "lift",\
+	"./postProcessing/forces/0/forces_0.dat" using ($1):($3) with lines title "drag"
+
+plot 	"./postProcessing/forces/0/forces.dat" using ($1):($4) with lines title "lift",\
+	"./postProcessing/forces/0/forces.dat" using ($1):($3) with lines title "drag"
+#pause -1
+#reread 

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/include/config

@@ -0,0 +1,38 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |				
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  9                                   	
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      config;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+config
+{
+    /* controlDict */
+    // Area of reference (projected area in x)
+    Aref 2.303064;
+
+    /* snappyHexMeshDict */
+    // Refinement regions
+    vr1_min ( -7.50 -3.00 -0.30 );
+    vr1_max ( 25.00 3.00 3.70 );
+
+    vr2_min ( -2.13 -1.99 -0.30 );
+    vr2_max ( 8.88 1.99 1.79 );
+
+    vr3_min ( 1.29 -1.49 -0.30 );
+    vr3_max ( 7.38 1.49 1.49 );
+
+    vr4_min ( 1.29 -0.99 -0.30 );
+    vr4_max ( 6.08 0.99 1.19 );
+}
+
+// ************************************************************************* //

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/include/geometry

@@ -0,0 +1,56 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  5                                     |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+
+//Name of .stl
+name_stl	car.stl;
+
+// Computational domain coordinates
+x_min		-15.0;
+x_max		25.0;
+
+y_min		-15.0;
+y_max		15.0;
+
+z_min		-0.3;
+z_max		14.7;
+
+cell_division		(80 60 30);
+// Refinement box coordinates
+
+//fine box close to the car
+x_min_ref		-1.25;
+x_max_ref		2.0;
+
+y_min_ref		-1.25;
+y_max_ref		1.25;
+
+z_min_ref		-0.3;
+z_max_ref		1.75;
+
+//medium box further away
+x_min_ref_medium		-2.0;
+x_max_ref_medium		10.0;
+
+y_min_ref_medium		-1.75;
+y_max_ref_medium		1.75;
+
+z_min_ref_medium		-0.3;
+z_max_ref_medium		2.25;
+
+//coarse box just before far field
+x_min_ref_coarse		-3.0;
+x_max_ref_coarse		15.0;
+
+y_min_ref_coarse		-2.75;
+y_max_ref_coarse		2.75;
+
+z_min_ref_coarse		-0.3;
+z_max_ref_coarse		2.75;
+
+
+// ************************************************************************* //

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/plots.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+dict=$1
+mkdir -p ./images
+#gnuplot $dict/forces
+gnuplot $dict/forceCoeffs_car
+gnuplot $dict/residuals

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/residuals

@@ -0,0 +1,15 @@
+set term pngcairo
+set output "./images/residuals.png"
+set logscale y
+set  yr [0.0000001:1]
+set title "Residuals"
+set ylabel 'Residual'
+set xlabel 'Iteration'
+plot "< cat logs/log.solver | grep 'Solving for Ux' | cut -d' ' -f9 | tr -d ','" title 'Ux' with lines,\
+     "< cat logs/log.solver | grep 'Solving for Uy' | cut -d' ' -f9 | tr -d ','" title 'Uy' with lines,\
+     "< cat logs/log.solver | grep 'Solving for Uz' | cut -d' ' -f9 | tr -d ','" title 'Uz' with lines,\
+     "< cat logs/log.solver | grep 'Solving for omega' | cut -d' ' -f9 | tr -d ','" title 'omega' with lines,\
+     "< cat logs/log.solver | grep 'Solving for k' | cut -d' ' -f9 | tr -d ','" title 'k' with lines,\
+     #"< cat logs/log.solver | grep 'Solving for p' | cut -d' ' -f9 | tr -d ','" title 'p' with lines
+#pause -1
+#reread 

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/run_all_shm.sh

@@ -0,0 +1,72 @@
+#!/bin/bash
+
+# Verify if already finished by checking the plotting folder
+ITERMAX=$(grep -o "endTime *[0-9]* *;" system/controlDict | grep -o "[0-9]*")
+if [[ -d images ]] && [[ -d $ITERMAX ]] && [[ -f simulation.done ]]; then
+    echo "Experiment at $(pwd) is already finished! Passing..."
+    exit 0
+fi
+
+mkdir -p logs
+
+# Following tries to recover automatically the numberOfSubdomains from system/decomposeParDict
+procs=$(grep -o "numberOfSubdomains *[0-9]* *;" system/decomposeParDict | grep -o "[0-9]*")
+# If doesn't work, set it manually here
+if [ -z $procs ]; then
+    echo "Couldn't read 'numberOfSubdomains' from 'system/decomposeParDict'."
+    procs=12
+fi
+echo "procs set to $procs."
+MAXITER=2500  # max iter of the simulations
+
+# If car.foam exists, then must have at least meshed -> skip
+if [[ ! -f car.foam ]]; then
+    foamCleanTutorials
+    #rm -rf 0 > /dev/null 2>&1
+
+    #PART DEDICATED TO MESHING
+    surfaceFeatures | tee logs/log.surfaceFeatures
+    blockMesh | tee logs/log.blockMesh
+
+    decomposePar
+    (time (mpirun -np $procs snappyHexMesh -parallel -overwrite)) 2>&1 | tee logs/log.shm
+    mpirun -np $procs checkMesh -parallel | tee logs/log.checkMesh
+
+    reconstructParMesh -constant
+    rm -r ./processor*
+
+    touch car.foam
+fi
+
+#PART DEDICATED TO SOLVER
+# If processor0 exists -> must have been doing solver (assuming not already finished and removed!)
+if [[ ! -d processor0 ]]; then
+    decomposePar -force -copyZero
+
+    mpirun -np $procs renumberMesh -parallel -overwrite | tee logs/log.renumber
+    mpirun -np $procs potentialFoam -parallel -writep | tee logs/log.potential
+fi
+(time (mpirun -np $procs simpleFoam -parallel)) 2>&1 | tee logs/log.solver
+
+# If solver has finished, do rest
+ENDTIME=$(grep -o "endTime *[0-9]* *;" system/controlDict | grep -o "[0-9]*")
+if [[ -d processor0/$ENDTIME ]]; then
+    reconstructPar -latestTime
+
+    rm -r ./processor*
+
+    ./plots.sh .
+
+    touch car.foam
+
+    touch simulation.done
+fi
+
+# # Copy UMean as U to compute vorticity on UMean automatically
+# cp $MAXITER/UMean $MAXITER/U
+
+# # Compute vorticity
+# postProcess -func vorticity -latestTime
+
+# # Remove copied U (ignore if non-existent)
+# rm -f $MAXITER/U

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/run_mesh_shm.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+
+# Following tries to recover automatically the numberOfSubdomains from system/decomposeParDict
+procs=$(grep -o "numberOfSubdomains *[0-9]* *;" system/decomposeParDict | grep -o "[0-9]*")
+# If doesn't work, set it manually here
+if [ -z $procs ]; then
+    echo "Couldn't read 'numberOfSubdomains' from 'system/decomposeParDict'."
+    procs=12
+fi
+echo "procs set to $procs."
+
+# If car.foam, then must have at least meshed -> skip
+if [[ ! -f car.foam ]]; then
+    foamCleanTutorials
+    #rm -rf 0 > /dev/null 2>&1
+
+    surfaceFeatures | tee logs/log.surfaceFeatures
+    blockMesh | tee logs/log.blockMesh
+
+    decomposePar
+    (time (mpirun -np $procs snappyHexMesh -parallel -overwrite)) 2>&1 | tee logs/log.shm
+    mpirun -np $procs checkMesh -parallel | tee logs/log.checkMesh
+
+    reconstructParMesh -constant
+    # rm -rf 0 > /dev/null 2>&1
+    # cp -r 0_org 0 > /dev/null 2>&1
+    rm -r ./processor*
+
+    touch car.foam
+fi

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/run_solver_shm.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+
+# Following tries to recover automatically the numberOfSubdomains from system/decomposeParDict
+procs=$(grep -o "numberOfSubdomains *[0-9]* *;" system/decomposeParDict | grep -o "[0-9]*")
+# If doesn't work, set it manually here
+if [ -z $procs ]; then
+    echo "Couldn't read 'numberOfSubdomains' from 'system/decomposeParDict'."
+    procs=12
+fi
+echo "procs set to $procs."
+
+#PART DEDICATED TO SOLVER
+# If processor0 -> must have been doing solver (assuming not already finished and removed!)
+if [[ ! -d processor0 ]]; then
+    decomposePar -force -copyZero
+
+    mpirun -np $procs renumberMesh -parallel -overwrite | tee logs/log.renumber
+    mpirun -np $procs potentialFoam -parallel -writep | tee logs/log.potential
+fi
+(time (mpirun -np $procs simpleFoam -parallel)) 2>&1 | tee logs/log.solver
+
+# If solver has finished, do rest
+ENDTIME=$(grep -o "endTime *[0-9]* *;" system/controlDict | grep -o "[0-9]*")
+if [[ -d processor0/$ENDTIME ]]; then
+    reconstructPar -latestTime
+
+    rm -r ./processor*
+
+    ./plots.sh .
+
+    touch car.foam
+fi

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/system/blockMeshDict

@@ -0,0 +1,121 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |				
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  9                                   	
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    format      ascii;
+    class       dictionary;
+    object      blockMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+convertToMeters 1;
+
+x_min -12;
+x_max  32;
+y_min  -4;
+y_max  4;
+z_min  -0.3;
+z_max  6.4;
+
+//xcells 22;
+//ycells 4;
+//zcells 4;
+
+
+//deltax 0.2;	//0.05
+//deltay 0.2;	//0.05
+//deltaz 0.2;	//0.05
+//
+//lx #calc "($xmax) - ($xmin)";
+//ly #calc "($ymax) - ($ymin)";
+//lz #calc "($zmax) - ($zmin)";
+//
+//xcells #calc "round(($lx)/($deltax))";
+//ycells #calc "round(($ly)/($deltay))";
+//zcells #calc "round(($lz)/($deltaz))";
+
+
+xcells 220; // MANUALLY CALCULATED BECAUSE WMAKE FAILED
+ycells 40;
+zcells 34;
+
+vertices
+(
+  ($x_min  $y_min  $z_min)
+  ($x_max  $y_min  $z_min)
+  ($x_max  $y_max  $z_min)
+  ($x_min  $y_max  $z_min)
+  ($x_min  $y_min  $z_max)
+  ($x_max  $y_min  $z_max)
+  ($x_max  $y_max  $z_max)
+  ($x_min  $y_max  $z_max)
+);
+
+blocks
+(
+    hex (0 1 2 3 4 5 6 7) ($xcells $ycells $zcells) simpleGrading (1 1 1)
+);
+
+edges
+(
+);
+
+boundary
+(
+    inlet
+    {
+        type patch;
+        faces
+        (
+            (0 4 7 3)
+        );
+    }
+
+    outlet
+    {
+        type patch;
+        faces
+        (
+            (2 6 5 1)
+        );
+    }
+
+    sides
+    {
+        type patch;
+        faces
+        (
+            (3 7 6 2)
+            (0 1 5 4)
+        );
+    }
+
+    ground
+    {
+        type wall;
+        faces
+        (
+            (0 3 2 1)
+        );
+    }
+
+    top
+    {
+        type patch;
+        faces
+        (
+            (4 5 6 7)
+        );
+    }
+);
+
+mergePatchPairs 
+(
+);
+
+// ************************************************************************* //

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/system/controlDict

@@ -0,0 +1,319 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  7                                     |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      controlDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+#include "../include/config"
+
+
+application     simpleFoam;
+
+// startFrom       startTime;
+startFrom       latestTime;
+
+startTime       0;
+
+stopAt          endTime;
+
+endTime         2500;	//1000-3000-5000
+averageStart    1500;   // 1K iters before the end
+
+deltaT          1;
+
+writeControl    timeStep;
+
+writeInterval   100;
+
+/*
+secondaryWriteControl    cpuTime;
+secondaryWriteInterval   1000; 
+secondaryPurgeWrite      1; 
+*/
+
+purgeWrite      2;
+
+writeFormat     binary;
+
+writePrecision  12;
+
+writeCompression off;	//uncompressed
+
+timeFormat      general;
+
+timePrecision   6;
+
+runTimeModifiable yes;
+
+
+
+
+// ************************************************************************* //
+
+functions
+{
+
+///////////////////////////////////////////////////////////////////////////
+car
+{
+    log yes;
+    enabled yes;
+
+    type forceCoeffs;
+    functionObjectLibs ( "libforces.so");
+
+    patches ( "car");
+
+    rho rhoInf;
+    rhoInf 1.205;
+
+    CofR ( 0 0 0);
+    liftDir ( 0 0 1);
+    dragDir ( 1 0 0);
+    pitchAxis ( 0 1 0);
+    magUInf 30;
+    lRef 1;  //length in x   //1;
+    Aref $!config/Aref;  //projected area in x   //drivAer=2.146952
+    writeControl timeStep;
+    writeInterval 1;
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////////
+
+yplus
+{
+    type                yPlus;
+    functionObjectLibs ("libfieldFunctionObjects.so");
+
+    enabled true;
+
+    writeControl outputTime;
+    //writeControl timeStep;
+    writeInterval 25;
+
+    log true;
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////////
+Q
+{
+    type                Q;
+    functionObjectLibs  ("libutilityFunctionObjects.so");
+
+    enabled true;
+
+    writeControl outputTime;
+    //writeControl timeStep;
+    //writeInterval 1;
+
+    //log true;
+}
+///////////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////////
+
+minmaxdomain_scalar
+{
+    type            volFieldValue;
+    libs            ("libfieldFunctionObjects.so");
+
+    enabled         true;   //true or false
+    log             true;   //write to screen
+    
+    //writeControl    writeTime;
+    writeControl    timeStep;
+    writeInterval   1;
+
+    writeFields     false;  //write solution to field value - Not needed when only reporting value to screen
+
+    writeLocation   true;   //write location in the output file
+
+    //mode component;
+
+    regionType      all;
+
+    operation       none;
+
+    fields
+    (
+        p k omega nut
+    );
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////////
+
+wallShearStress1
+{
+    type                wallShearStress;
+    functionObjectLibs  ("libutilityFunctionObjects.so");
+
+    enabled true;
+
+    writeControl outputTime;
+    //writeControl timeStep;
+    //writeInterval 1;
+
+    //log true;
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////////
+
+    fieldAverage
+    {
+        type            fieldAverage;
+        functionObjectLibs ("libfieldFunctionObjects.so");
+        enabled         true;
+        writeControl   outputTime;
+
+	//writeControl   timeStep;
+	//writeInterval  100;
+
+	//cleanRestart true;
+
+	timeStart       $!averageStart;  // see top of file, should be 1K iters before endTime
+	//timeEnd         1000;
+
+        fields
+        (
+            U
+            {
+                mean        on;
+                prime2Mean  on;
+                base        time;
+            }
+
+            p
+            {
+                mean        on;
+                prime2Mean  on;
+                base        time;
+            }
+
+            nut
+            {
+                mean        on;
+                prime2Mean  on;
+                base        time;
+            }
+
+            k
+            {
+                mean        on;
+                prime2Mean  off;
+                base        time;
+            }
+
+            omega
+            {
+                mean        on;
+                prime2Mean  off;
+                base        time;
+            }
+
+            Q
+            {
+                mean        on;
+                prime2Mean  off;
+                base        time;
+            }
+
+            yPlus
+            {
+                mean        on;
+                prime2Mean  off;
+                base        time;
+            }
+
+            wallShearStress
+            {
+                mean        on;
+                prime2Mean  off;
+                base        time;
+            }
+
+        );
+    }
+
+///////////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////////
+
+minmaxdomain_vector
+{
+    type            volFieldValue;
+    libs            ("libfieldFunctionObjects.so");
+
+    enabled         true;   //true or false
+    log             true;   //write to screen
+    
+    //writeControl    writeTime;
+    writeControl    timeStep;
+    writeInterval   1;
+
+    writeFields     false;  //write solution to field value - Not needed when only reporting value to screen
+
+    writeLocation   true;   //write location in the output file
+
+    //mode component;
+
+    regionType      all;
+
+    operation       none;
+
+    fields
+    (
+        U
+    );
+}
+
+mindomain_scalar
+{
+    $minmaxdomain_scalar
+    operation       min;
+}
+
+mindomain_vector
+{
+    $minmaxdomain_vector
+    operation       minMag;
+}
+
+maxdomain_scalar
+{
+    $minmaxdomain_scalar
+    operation       max;
+}
+
+maxdomain_vector
+{
+    $minmaxdomain_vector
+    operation       maxMag;
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+
+};

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/system/decomposeParDict

@@ -0,0 +1,19 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  7                                     |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      decomposeParDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+    numberOfSubdomains 12;
+    method scotch;
+

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/system/fvConstraints

@@ -0,0 +1,28 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |				
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  9                                   	
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    format      ascii;
+    class       dictionary;
+    object      fvConstraints;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+//To control on/off just modify the value.
+//In this case a large value is like off
+//Use from the begining so the object it is created
+
+limitU
+{
+    type            limitVelocity;
+    selectionMode   all;
+    max             200;	//100 - 10000 (large value is off)
+}
+
+//************************************************************************** //
+

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/system/fvSchemes

@@ -0,0 +1,69 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |				
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  9                                   	
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    format      ascii;
+    class       dictionary;
+    object      fvSchemes;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+    ddtSchemes
+    {
+        default 	steadyState;
+    }
+
+    gradSchemes
+    {
+        //default 	Gauss linear;
+        default 	cellLimited Gauss linear 1;
+        grad(U) 	cellLimited Gauss linear 1;
+        grad(k) 	cellLimited Gauss linear 1;
+        grad(omega) 	cellLimited Gauss linear 1;
+        grad(p) 	cellLimited Gauss linear 0.333;
+    }
+
+    divSchemes
+    {
+        default 		none;
+
+        //div(phi,U) 		bounded Gauss linearUpwindV grad(U);
+        div(phi,U) 		bounded Gauss linearUpwind grad(U);
+
+        //div(phi,k) 		bounded Gauss linearUpwind grad(k);
+        //div(phi,omega) 	bounded Gauss linearUpwind grad(omega);
+        div(phi,k) 		bounded Gauss upwind;
+        div(phi,omega) 		bounded Gauss upwind;
+
+        div((nuEff*dev2(T(grad(U))))) Gauss linear;
+
+//For potentialFoam
+        div(div(phi,U))   	Gauss linear;
+
+    }
+
+    interpolationSchemes
+    {
+        //default linear;
+        default skewCorrected linear;
+    }
+
+    laplacianSchemes
+    {
+        default Gauss linear limited 0.5;
+    }
+
+    snGradSchemes
+    {
+        default limited 0.5;
+    }
+
+    wallDist
+    {
+        method meshWave;
+    }

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/system/fvSolution

@@ -0,0 +1,181 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |				
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  9                                   	
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    format      ascii;
+    class       dictionary;
+    object      fvSolution;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+    solvers
+    {
+        p
+        {
+
+        solver          GAMG;
+        tolerance       1e-06;
+        relTol          0.01;
+        smoother        GaussSeidel;
+        nPreSweeps      0;
+        nPostSweeps     2;
+        nFinestSweeps   2;
+        cacheAgglomeration on;
+        nCellsInCoarsestLevel 10;
+        agglomerator    faceAreaPair;
+        mergeLevels     1;
+/*
+
+        solver          PCG;
+        preconditioner
+        {
+            preconditioner  GAMG;
+            tolerance       1e-06;	//1e-06 1e-08
+            relTol          0.0;	//0.01 0
+            nVcycles        2;
+            smoother        GaussSeidel;
+            nPreSweeps      0;
+            nPostSweeps     2;
+            nFinestSweeps   2;
+            cacheAgglomeration false;
+            nCellsInCoarsestLevel 10;
+            agglomerator    faceAreaPair;
+            mergeLevels     1;
+        }
+
+        tolerance       1e-06;
+        relTol          0.01;
+        //maxIter         20;
+
+
+        solver          PCG;
+        preconditioner  DIC;
+        tolerance       1e-6;
+        relTol          0.01;
+*/
+
+            minIter 3;
+        }
+
+        U
+        {
+            solver          PBiCGStab;
+            preconditioner  DILU;
+            tolerance       1e-08;	//1e-08
+            relTol          0.001;	//0.1 0.01
+
+            minIter 3;
+        }
+
+        k
+        {
+            solver          PBiCGStab;
+            preconditioner  DILU;
+            tolerance       1e-08;	//1e-08
+            relTol          0.001;	//0.1 0.01
+
+            minIter 3;
+        }
+
+        omega
+        {
+            solver          PBiCGStab;
+            preconditioner  DILU;
+            tolerance       1e-08;	//1e-08
+            relTol          0.001;	//0.1 0.01
+
+            minIter 3;
+        }
+
+/*
+    Phi
+    {
+        $p;
+    }
+*/
+
+        Phi
+        {
+            solver GAMG;
+            agglomerator faceAreaPair;
+            mergeLevels 1;
+            cacheAgglomeration true;
+            nCellsInCoarsestLevel 200;
+            tolerance 1e-8;
+            relTol 0.001;
+            smoother GaussSeidel;
+            nPreSweeps 0;
+            nPostSweeps 2;
+            nFinestSweeps 2;
+            minIter 3;
+        }
+
+    }
+
+    potentialFlow
+    {
+        nNonOrthogonalCorrectors 10;
+    }
+
+    SIMPLE
+    {
+        consistent yes;
+        nNonOrthogonalCorrectors 2;
+
+        pRefCell 0;
+        pRefValue 0;
+
+        residualControl
+        {
+            p 		1.0e-4;
+            U 		1.0e-4;
+            k 		1.0e-4;
+            omega 	1.0e-4;
+        }
+
+    }
+
+//SIMPLE
+/*
+    relaxationFactors
+    {
+        fields
+        {
+            p     0.3;
+	}
+
+        equations
+        {
+            U     0.7;
+            k     0.5;
+            omega 0.5;
+        }
+
+    }
+*/
+
+//SIMPLEC
+
+    relaxationFactors
+    {
+        fields
+        {
+	       //".*"  0.7;
+            p     0.9;
+        }
+        equations
+        {
+	       //".*"  0.7;
+            p     0.9;
+            U     0.7;
+            k     0.7;
+            omega 0.7;
+        }
+    }
+
+

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/system/meshQualityDict

@@ -0,0 +1,48 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |				
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  9                                   	
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    format      ascii;
+    class       dictionary;
+    object      meshQualityDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+
+maxNonOrtho 75;
+maxBoundarySkewness 4;	//Original 20 for better quality 4
+maxInternalSkewness 4;
+
+/*
+maxNonOrtho 180;
+maxBoundarySkewness -1;	
+maxInternalSkewness -1;
+*/
+
+maxConcave 80;
+
+minVol 1e-13;
+
+minTetQuality -1e+30;
+
+minArea -1;
+
+minTwist 0.02;
+
+minDeterminant 0.001;
+
+minFaceWeight 0.05;
+//minFaceWeight 0.02;
+
+minVolRatio 0.01;
+
+minTriangleTwist -1;
+
+//minFlatness 0.5;
+
+// ************************************************************************* //

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/system/snappyHexMeshDict

@@ -0,0 +1,322 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  7                                     |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      snappyHexMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+#include "../include/config"
+
+/***************************************************/
+castellatedMesh 	true;
+snap 			true;
+addLayers 		true;
+/***************************************************/
+
+
+
+/***************************************************/
+
+geometry
+{
+
+    car.stl
+    {
+        type triSurfaceMesh;
+        name car;
+    }
+
+
+    vr1
+    {
+        type searchableBox;
+        min $!config/vr1_min;
+        max $!config/vr1_max;
+    }
+
+    vr2
+    {
+        type searchableBox;
+        min $!config/vr2_min;
+        max $!config/vr2_max;
+    }
+
+    vr3
+    {
+        type searchableBox;
+        min $!config/vr3_min;
+        max $!config/vr3_max;
+    }
+
+    vr4
+    {
+        type searchableBox;
+        min $!config/vr4_min;
+        max $!config/vr4_max;
+    }
+
+
+    /*
+    vr1
+    {
+        type searchableBox;
+        min ( -7.5 -3.0 -0.3 );
+        max ( 25.0 3.0 3.7 );
+    }
+
+    vr2
+    {
+        type searchableBox;
+        //min ( -3.0 0.0 0.0 );
+        //max ( 15.0 2.0 3.0 );
+        min ( -2.0 -2.0 -0.3 );
+        max (  9.0 2.0 1.7 );  // 6.0 2.0 1.7
+    }
+
+    vr3
+    {
+        type searchableBox;
+        min ( 2.5 -1.5 -0.3 );
+        max ( 7.5 1.5 1.4 );  // 6.5 1.5 1.4
+    }
+
+    vr4
+    {
+        type searchableBox;
+        min ( 3.2 -1 -0.3 );
+        max ( 6.2 1.0 1.0 );  // 5.2 1.0 1.0
+    }
+    */
+}
+
+/***************************************************/
+
+
+
+/***************************************************/
+
+castellatedMeshControls
+{
+
+    maxLocalCells 5000000;
+    maxGlobalCells 30000000;		//*******
+    minRefinementCells 0;
+    nCellsBetweenLevels 10;  // 5
+    resolveFeatureAngle 30.0;		//curvature
+    allowFreeStandingZoneFaces true;
+    planarAngle 30.0;
+    maxLoadUnbalance 0.1;
+
+    locationInMesh (10.0 1.0 1.0 );
+
+
+//////////////////////////////////////
+    features
+    (
+    
+        {
+            file "car.eMesh";
+            levels ((0.025 0));
+            //level 0;
+        }
+
+    );
+//////////////////////////////////////
+
+
+//////////////////////////////////////
+    refinementSurfaces
+    {
+        car
+        {
+            level ( 4 5 );	// 2 4 - 4 4
+        }
+
+    }
+//////////////////////////////////////
+
+
+//////////////////////////////////////
+    refinementRegions
+    {
+
+        vr1
+        {
+            mode inside;
+            levels (( 1E5 1 ));
+        }
+
+        vr2
+        {
+            mode inside;	
+            levels (( 1E5 2 ));
+        }
+
+        vr3
+        {
+            mode inside;
+            levels (( 1E5 3 ));
+        }
+
+        vr4
+        {
+            mode inside;
+            levels (( 1E5 4 ));  // 1E5 4
+        }
+
+    }
+//////////////////////////////////////
+
+}
+
+/***************************************************/
+
+
+
+/***************************************************/
+
+snapControls
+{
+
+// Number of patch smoothing iterations before finding correspondence
+// to surface
+nSmoothPatch 3;	//recommended
+//nSmoothPatch 10;	//improved
+
+tolerance 2.0;
+//tolerance 1.0;
+
+nSolveIter 30;	//recommended
+//nSolveIter 100;	//improved
+
+nRelaxIter 5;	//default
+//nRelaxIter 10;	//improved	10-20-50
+
+// Feature snapping
+
+    // Number of feature edge snapping iterations.
+    // Leave out altogether to disable.
+    nFeatureSnapIter 10;		//recommended
+    //nFeatureSnapIter 100;		//improved	20-50-100
+
+    // Detect (geometric only) features by sampling the surface
+    // (default=false).
+    implicitFeatureSnap false;
+
+    // Use castellatedMeshControls::features (default = true)
+    explicitFeatureSnap true;
+
+    // Detect features between multiple surfaces
+    // (only for explicitFeatureSnap, default = false)
+    multiRegionFeatureSnap false;
+
+}
+
+/***************************************************/
+
+
+
+
+/***************************************************/
+
+addLayersControls
+{
+
+/////////////////////////////////////////////
+    relativeSizes true;
+
+    expansionRatio 1.2;		//1.0;
+    finalLayerThickness 0.3;
+    minThickness 0.01;		//0.1 0.25
+/////////////////////////////////////////////
+
+
+    layers
+    {
+
+        car
+        {
+            nSurfaceLayers 6;
+            expansionRatio 1.1;
+            finalLayerThickness 0.3;
+            minThickness 0.01;
+        }
+
+        ground
+        {
+            nSurfaceLayers 6;
+            expansionRatio 1.2;
+            finalLayerThickness 0.3;
+            minThickness 0.01;
+        }
+
+    }
+
+
+/////////////////////////////////////////////
+    nGrow 0;
+
+    featureAngle 130.0;
+
+    maxFaceThicknessRatio 0.5;
+
+    nSmoothSurfaceNormals 1;
+    nSmoothNormals 3;
+    nSmoothThickness 10;
+
+    slipFeatureAngle 30.0;
+    nRelaxIter 5;
+
+    maxThicknessToMedialRatio 0.3;
+
+    minMedialAxisAngle 90;
+    minMedianAxisAngle 90;
+
+    nBufferCellsNoExtrude 0;
+    nLayerIter 50;
+    nRelaxedIter 20;
+
+    //writeVTK false;
+    //noErrors false;
+    //layerRecovery 1;
+    //growZoneLayers false;
+    //projectGrownUp 0.0;
+/////////////////////////////////////////////
+
+}
+
+/***************************************************/
+
+
+
+
+/***************************************************/
+
+meshQualityControls
+{
+    #include "meshQualityDict"
+
+    nSmoothScale 4;
+    errorReduction 0.75;
+
+    relaxed
+    {
+        maxNonOrtho 75;
+    }
+
+}
+
+/***************************************************/
+
+
+debug 0;
+mergeTolerance 1.0E-6;
+//autoBlockMesh false;

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/system/surfaceFeaturesDict

@@ -0,0 +1,34 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |				
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Version:  9                                   	
+     \\/     M anipulation  |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    format      ascii;
+    class       dictionary;
+    object      surfaceFeatureExtractDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+surfaces ("car.stl");
+
+extractionMethod    extractFromSurface;
+
+includedAngle   150;
+
+subsetFeatures
+{
+    // Keep nonManifold edges (edges with >2 connected faces)
+    nonManifoldEdges       yes;
+
+    // Keep open edges (edges with 1 connected face)
+    openEdges       yes;
+}
+
+// Write features to obj format for postprocessing
+writeObj                yes;
+
+// ************************************************************************* //

cfd_workflow_20261012/_seiler_ref/physiopt_new_scripts/compute_force_chair.py

@@ -0,0 +1,259 @@
+import argparse
+import trimesh
+import numpy as np
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d.art3d import Poly3DCollection
+import os
+import json
+
+
+def detect_seat_bbox_auto(mesh_path, up_axis=1, shrink_factor=0.60):
+    """
+    Détecte la Bounding Box de l'assise d'une chaise avec calcul automatique de l'épaisseur.
+    - shrink_factor: Réduit la taille (X, Z) pour analyser uniquement le "cœur" de l'assise
+                     et éviter de prendre en compte les pieds sur les côtés. (0.60 = 60% du centre)
+    """
+    # 1. Charger le mesh
+    mesh = trimesh.load(mesh_path, force='mesh')
+    up_vector = np.zeros(3)
+    up_vector[up_axis] = 1.0
+    bounds_min, bounds_max = mesh.bounds
+    mesh.vertices = (mesh.vertices - bounds_min) / (bounds_max - bounds_min)
+
+    # 2. Filtrer les faces horizontales
+    dot_products = np.dot(mesh.face_normals, up_vector)
+    horizontal_faces_mask = dot_products > 0.85
+    
+    if not np.any(horizontal_faces_mask):
+        return None, None, mesh
+
+    horizontal_faces = mesh.faces[horizontal_faces_mask]
+    horizontal_vertices = mesh.vertices[np.unique(horizontal_faces.flatten())]
+
+    # 3. Trouver la hauteur principale de l'assise
+    heights = horizontal_vertices[:, up_axis]
+    hist, bin_edges = np.histogram(heights, bins=30, range=(0, 1))
+    peak_bin = np.argmax(hist) 
+    seat_height_center = (bin_edges[peak_bin] + bin_edges[peak_bin + 1]) / 2.0
+
+    # 4. Isoler les sommets de la surface de l'assise
+    seat_vertices = horizontal_vertices[np.abs(horizontal_vertices[:, up_axis] - seat_height_center) < 0.05]
+    if len(seat_vertices) == 0:
+        return None, None, mesh
+
+    # Bounding Box de base de la surface
+    min_bounds = np.min(seat_vertices, axis=0)
+    max_bounds = np.max(seat_vertices, axis=0)
+
+    # 5. Réduire vers le centre sur les axes horizontaux
+    axes_horizontaux = [i for i in range(3) if i != up_axis]
+    for axis in axes_horizontaux:
+        center = (max_bounds[axis] + min_bounds[axis]) / 2.0
+        length = max_bounds[axis] - min_bounds[axis]
+        min_bounds[axis] = center - (length * shrink_factor / 2.0)
+        max_bounds[axis] = center + (length * shrink_factor / 2.0)
+
+    # --- 6. CALCUL AUTOMATIQUE DE L'ÉPAISSEUR ---
+    
+    # On récupère les limites X et Z de notre "colonne" centrale
+    min_h1, min_h2 = min_bounds[axes_horizontaux[0]], min_bounds[axes_horizontaux[1]]
+    max_h1, max_h2 = max_bounds[axes_horizontaux[0]], max_bounds[axes_horizontaux[1]]
+
+    # On sélectionne tous les points du mesh complet qui sont dans cette colonne
+    col_mask = (mesh.vertices[:, axes_horizontaux[0]] >= min_h1) & \
+               (mesh.vertices[:, axes_horizontaux[0]] <= max_h1) & \
+               (mesh.vertices[:, axes_horizontaux[1]] >= min_h2) & \
+               (mesh.vertices[:, axes_horizontaux[1]] <= max_h2)
+    column_vertices = mesh.vertices[col_mask]
+    
+    y_values = column_vertices[:, up_axis]
+
+    def find_boundary(y_array, direction, gap_threshold=0.04):
+        # direction: -1 pour chercher vers le bas, 1 pour chercher vers le haut
+        if len(y_array) == 0:
+            return seat_height_center
+            
+        # Trier les hauteurs (décroissant si on va vers le bas, croissant si on va vers le haut)
+        if direction == -1:
+            y_sorted = np.sort(y_array[y_array <= seat_height_center + 0.01])[::-1]
+        else:
+            y_sorted = np.sort(y_array[y_array >= seat_height_center - 0.01])
+
+        if len(y_sorted) < 2:
+            return y_sorted[0] if len(y_sorted)>0 else seat_height_center
+
+        # Calculer l'espace (gap) entre chaque point consécutif
+        gaps = np.abs(y_sorted[:-1] - y_sorted[1:])
+        
+        # Trouver le premier endroit où le trou est plus grand que notre seuil
+        large_gaps = np.where(gaps > gap_threshold)[0]
+        
+        if len(large_gaps) > 0:
+            return y_sorted[large_gaps[0]] # On renvoie le point juste avant le vide
+        return y_sorted[-1] # Si c'est un bloc plein jusqu'au bout, on prend la fin
+
+    # 1. Calculer le bas et le haut EXACTS de l'assise
+    # (Attention, j'ai remis gap_threshold=0.04 pour le bottom, tu avais mis 0.4 dans ton message, 
+    # ce qui risquait de faire descendre la boîte jusqu'au sol !)
+    seat_bottom_exact = find_boundary(y_values, direction=-1, gap_threshold=0.4)
+    seat_top_exact = find_boundary(y_values, direction=1, gap_threshold=0.04)
+
+    # 2. Définir tes marges (ex: 0.02 = 2% de la hauteur totale de la chaise)
+    margin_bottom = 0.02 
+    margin_top = 0.02
+
+    # 3. Appliquer les marges tout en restant dans les limites normalisées (0.0 à 1.0)
+    seat_bottom = max(0.0, seat_bottom_exact - margin_bottom)
+    seat_top = min(1.0, seat_top_exact + margin_top)
+
+    min_bounds[up_axis] = seat_bottom
+    max_bounds[up_axis] = seat_top
+
+    return min_bounds, max_bounds, mesh
+
+
+def get_box_faces(min_b, max_b):
+    """Génère les 6 faces d'une Bounding Box 3D pour matplotlib."""
+    x0, y0, z0 = min_b
+    x1, y1, z1 = max_b
+    verts = [
+        [x0, y0, z0], [x1, y0, z0], [x1, y1, z0], [x0, y1, z0],
+        [x0, y0, z1], [x1, y0, z1], [x1, y1, z1], [x0, y1, z1]
+    ]
+    faces = [
+        [verts[0], verts[1], verts[2], verts[3]], 
+        [verts[4], verts[5], verts[6], verts[7]], 
+        [verts[0], verts[1], verts[5], verts[4]], 
+        [verts[2], verts[3], verts[7], verts[6]], 
+        [verts[1], verts[2], verts[6], verts[5]], 
+        [verts[0], verts[3], verts[7], verts[4]]  
+    ]
+    return faces
+
+
+def render_chair_bbox(mesh, min_bound, max_bound, output_filename):
+    """Génère 1 seule image contenant les 3 rendus avec correction de l'axe vertical (Y -> Z)."""
+    
+    # 1. Échantillonner le mesh
+    num_vertices = len(mesh.vertices)
+    step = max(1, num_vertices // 5000) 
+    sampled_vertices = mesh.vertices[::step]
+
+    # --- L'ASTUCE EST ICI ---
+    # On isole les axes et on échange Y et Z pour l'affichage matplotlib
+    x_plot = sampled_vertices[:, 0]
+    y_plot = sampled_vertices[:, 2] # La profondeur du mesh devient l'axe Y de matplotlib
+    z_plot = sampled_vertices[:, 1] # La hauteur du mesh (Y) devient l'axe vertical Z de matplotlib
+
+    # 2. Récupérer les faces de la boîte et échanger aussi Y et Z
+    box_faces = get_box_faces(min_bound, max_bound)
+    box_faces_z_up = []
+    for face in box_faces:
+        # Pour chaque point [x, y, z], on crée [x, z, y]
+        new_face = [[v[0], v[2], v[1]] for v in face]
+        box_faces_z_up.append(new_face)
+
+    # 3. Récupérer les limites et échanger Y et Z
+    b = mesh.bounds
+    min_x, max_x = b[0][0], b[1][0]
+    min_y, max_y = b[0][2], b[1][2] # Ancien Z
+    min_z, max_z = b[0][1], b[1][1] # Ancien Y
+
+    # 4. Définir les vues adaptées (Maintenant que Z est bien en haut)
+    views = [
+        {"name": "Isométrique", "elev": 20, "azim": -45},
+        {"name": "Face", "elev": 0, "azim": -90},  # Regarde l'avant de la chaise
+        {"name": "Profil", "elev": 0, "azim": 0}   # Regarde le côté
+    ]
+
+    fig = plt.figure(figsize=(18, 6))
+
+    for i, view in enumerate(views, start=1):
+        ax = fig.add_subplot(1, 3, i, projection='3d')
+        
+        # A. Dessiner la chaise avec nos axes modifiés
+        ax.scatter(
+            x_plot, y_plot, z_plot,
+            c='gray', s=2, alpha=0.4, marker='.'
+        )
+        
+        # B. Dessiner la Bounding Box avec nos axes modifiés
+        box_col = Poly3DCollection(box_faces_z_up, alpha=0.4, facecolors='red', edgecolors='darkred')
+        ax.add_collection3d(box_col)
+        
+        # C. Cadrage de la caméra
+        ax.set_xlim(min_x, max_x)
+        ax.set_ylim(min_y, max_y)
+        ax.set_zlim(min_z, max_z)
+        
+        # Conserver les proportions
+        try:
+            ax.set_box_aspect((max_x-min_x, max_y-min_y, max_z-min_z))
+        except AttributeError:
+            pass
+        
+        # Appliquer l'angle de vue
+        ax.view_init(elev=view["elev"], azim=view["azim"])
+        ax.set_title(f"Vue : {view['name']}")
+        ax.set_axis_off()
+
+    plt.tight_layout()
+    plt.savefig(output_filename, dpi=150, bbox_inches='tight')
+    plt.close(fig) 
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Batch process chair meshes to extract seat bbox.")
+    parser.add_argument("--folder", required=True, help="Input directory containing chair folders.")
+    parser.add_argument("--instance-file", required=True, help="File with instance to optimize")
+    parser.add_argument("-s", "--shrink", type=float, default=0.60, help="Shrink factor for bbox (default: 0.60).")
+    parser.add_argument("-r", "--rotation", choices=['none', 'x_up', 'y_up'], default='y_up', help="Rotation fix (default: y_up).")
+    args = parser.parse_args()
+
+    # Chemins ajustés
+    input_folder = f"/scratch/cvlab/home/seiler/physiopt_new/output/hunyuan_gen/{args.folder}"
+    output_folder = f"/scratch/cvlab/home/seiler/physiopt_new/output_force/hunyuan_gen/{args.folder}"
+    os.makedirs(output_folder, exist_ok=True)
+    print(f"Processing folders in: {input_folder}")
+
+    with open(os.path.join("file_for_exp", args.instance_file), "r") as f:
+        instance_optimize = json.load(f)
+    count = 0
+
+    for folder_name in os.listdir(input_folder):
+        if folder_name in instance_optimize:
+            input_subdir = os.path.join(input_folder, folder_name)
+            mesh_file = os.path.join(input_subdir, "generated_mesh.obj")
+            
+            if os.path.isdir(input_subdir) and os.path.exists(mesh_file):
+                out_subdir = os.path.join(output_folder, folder_name)
+                os.makedirs(out_subdir, exist_ok=True)
+
+                try:
+                    # Traitement de la chaise
+                    min_bounds, max_bounds, mesh = detect_seat_bbox_auto(mesh_file)
+                    # Construction de l'output force [x_min, x_max, y_min, y_max, z_min, z_max]
+                    config = {
+                        "force": [0.0, -300000.0, 0.0],
+                        "force_region_mode": "bbox",
+                        "force_bbox_ratio": [
+                            float(min_bounds[0]), float(max_bounds[0]),
+                            float(min_bounds[1]), float(max_bounds[1]),
+                            float(min_bounds[2]), float(max_bounds[2])
+                        ]
+                    }
+                    
+                    with open(os.path.join(out_subdir, "force_config.json"), 'w') as f:
+                        json.dump(config, f, indent=2)
+                        
+                    render_chair_bbox(mesh, min_bounds, max_bounds, os.path.join(out_subdir, "plot.png"))
+                    print(f"✅ Success: {folder_name}")
+                    count += 1
+                    
+                except Exception as e:
+                    print(f"❌ Failed: {folder_name} | Error: {e}")
+
+    print(f"🎉 Batch processing complete for {count} shapes")
+
+if __name__ == "__main__":
+    main()

cfd_workflow_20261012/_seiler_ref/physiopt_new_scripts/compute_force_table.py

@@ -0,0 +1,154 @@
+import argparse
+import trimesh
+import numpy as np
+
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d.art3d import Poly3DCollection
+import os
+import json
+
+def process_mesh(mesh_path, rot_fix, margin):
+    """Loads mesh, fixes orientation, normalizes Z, and calculates t_final."""
+    mesh = trimesh.load(mesh_path, force='mesh')
+    
+    # Fix orientation
+    if rot_fix == 'y_up':
+        q = trimesh.transformations.quaternion_about_axis(np.radians(90), [1, 0, 0])
+        mesh.apply_transform(trimesh.transformations.quaternion_matrix(q))
+    elif rot_fix == 'x_up':
+        q = trimesh.transformations.quaternion_about_axis(np.radians(-90), [1, 0, 0])
+        mesh.apply_transform(trimesh.transformations.quaternion_matrix(q))
+
+    # Normalize Z axis between 0 and 1
+    z_min, z_max = mesh.vertices[:, 2].min(), mesh.vertices[:, 2].max()
+    mesh.vertices[:, 2] = (mesh.vertices[:, 2] - z_min) / (z_max - z_min)
+
+    # Find downward-facing faces in the upper half of the mesh
+    mask = (mesh.face_normals[:, 2] < -0.8) & (mesh.triangles_center[:, 2] > 0.5)
+    z_vals = np.round(mesh.triangles_center[mask, 2], decimals=3)
+    areas = mesh.area_faces[mask]
+
+    # Find the Z level with the largest flat area
+    unique_z = np.unique(z_vals)
+    t_exact = unique_z[np.argmax([np.sum(areas[z_vals == z]) for z in unique_z])]
+
+    # Calculate t_final with the adaptive margin
+    t_final = float(t_exact - ((1.0 - t_exact) * margin))
+    return mesh, t_final
+
+
+def save_plot(mesh, t, save_path):
+    """Saves a 3D PNG plot instantly using a point cloud for the mesh."""
+    fig = plt.figure(figsize=(18, 6))
+    
+    # 1. Obtenir les limites pour la taille du plan
+    b = mesh.bounds
+    mx, my = (b[1] - b[0])[:2] * 0.2
+    min_x, max_x = b[0][0] - mx, b[1][0] + mx
+    min_y, max_y = b[0][1] - my, b[1][1] + my
+    
+    plane_verts = [[
+        (min_x, min_y, t), (max_x, min_y, t),
+        (max_x, max_y, t), (min_x, max_y, t)
+    ]]
+
+    # --- L'ASTUCE EST ICI ---
+    # Au lieu d'extraire les faces, on prend juste les sommets (vertices).
+    # On calcule un 'step' pour ne garder qu'environ 5000 points maximum.
+    # C'est largement suffisant pour voir la forme de la table sans faire ramer le PC.
+    num_vertices = len(mesh.vertices)
+    step = max(1, num_vertices // 5000) 
+    sampled_vertices = mesh.vertices[::step]
+    # ------------------------
+
+    views = [
+        {"title": "Vue Isométrique", "elev": 30, "azim": 45},
+        {"title": "Vue de Profil (Z)", "elev": 0, "azim": 0},
+        {"title": "Vue de Dessous", "elev": -90, "azim": 0}
+    ]
+
+    for i, view in enumerate(views, start=1):
+        ax = fig.add_subplot(1, 3, i, projection='3d')
+        
+        # Afficher la table comme un nuage de points (ultra rapide)
+        ax.scatter(
+            sampled_vertices[:, 0], sampled_vertices[:, 1], sampled_vertices[:, 2],
+            c='gray', s=1, alpha=0.3, marker='.'
+        )
+        
+        # Le plan reste un polygone (il n'a que 4 sommets, donc c'est instantané)
+        plane_col = Poly3DCollection(plane_verts, alpha=0.5, facecolors='red')
+        ax.add_collection3d(plane_col)
+        
+        ax.set_xlim(min_x, max_x)
+        ax.set_ylim(min_y, max_y)
+        ax.set_zlim(b[0][2], b[1][2])
+        
+        try:
+            ax.set_box_aspect((max_x-min_x, max_y-min_y, b[1][2]-b[0][2]))
+        except AttributeError:
+            pass
+        
+        ax.view_init(elev=view["elev"], azim=view["azim"])
+        ax.set_title(view["title"])
+        ax.set_xlabel('X')
+        ax.set_ylabel('Y')
+        ax.set_zlabel('Z')
+
+    plt.suptitle(f"Table Bottom Z = {t:.3f}", fontsize=16)
+    
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=150, bbox_inches='tight')
+    plt.close(fig)
+
+
+def main():
+    # --- Parse Command Line Arguments ---
+    parser = argparse.ArgumentParser(description="Batch process table meshes to extract bottom T value.")
+    parser.add_argument("--folder", required=True, help="Input directory containing table folders.")
+    parser.add_argument("--instance-file", required=True, help="File with instance to optimize")
+    parser.add_argument("-m", "--margin", type=float, default=0.5, help="Margin percentage (default: 0.5).")
+    parser.add_argument("-r", "--rotation", choices=['none', 'x_up', 'y_up'], default='y_up', help="Rotation fix (default: y_up).")
+    args = parser.parse_args()
+
+    input_folder = "/scratch/cvlab/home/seiler/physiopt_new/output/hunyuan_gen" + f"/{args.folder}"
+    output_folder = "/scratch/cvlab/home/seiler/physiopt_new/output_force/hunyuan_gen" + f"/{args.folder}"
+    os.makedirs(output_folder, exist_ok=True)
+    print(f"Processing folders in: {input_folder}")
+
+    with open(os.path.join("file_for_exp", args.instance_file), "r") as f:
+        instance_optimize = json.load(f)
+    count = 0
+
+    # --- Batch Processing Loop ---
+    for folder_name in os.listdir(input_folder):
+        if folder_name in instance_optimize:
+            input_subdir = os.path.join(input_folder, folder_name)
+            mesh_file = os.path.join(input_subdir, "generated_mesh.obj")
+            
+            if os.path.isdir(input_subdir) and os.path.exists(mesh_file):
+                out_subdir = os.path.join(output_folder, folder_name)
+                os.makedirs(out_subdir, exist_ok=True)
+
+                try:
+                    mesh, t_final = process_mesh(mesh_file, args.rotation, args.margin)
+                    
+                    config = {
+                        "force": [0.0, -100000.0, 0.0],
+                        "force_region_mode": "bbox",
+                        "force_bbox_ratio": [0.0, 1.0, 1.0, t_final, 0.0, 1.0]
+                    }
+                    with open(os.path.join(out_subdir, "force_config.json"), 'w') as f:
+                        json.dump(config, f, indent=2)
+                        
+                    save_plot(mesh, t_final, os.path.join(out_subdir, "plot.png"))
+                    print(f"✅ Success: {folder_name} (t_final={t_final:.3f})")
+                    count += 1
+                    
+                except Exception as e:
+                    print(f"❌ Failed: {folder_name} | Error: {e}")
+
+    print(f"🎉 Batch processing complete for {count} shape")
+
+if __name__ == "__main__":
+    main()

cfd_workflow_20261012/_seiler_ref/physiopt_new_scripts/compute_metrics.py

@@ -0,0 +1,169 @@
+import os
+import argparse
+import logging
+import json
+import torch
+import trimesh
+from tqdm.auto import tqdm
+
+# Custom imports (ensure these are available in your PYTHONPATH)
+import sys
+sys.path.append("../smoothSDF")
+from src_optimization.global_metrics import compute_final_distribution_metrics
+from src_optimization.features_extractor import PointNetExtractor, DINOv2Extractor, InceptionV3Extractor
+from src_optimization.features_extractor import extract_features_step
+
+def setup_logging():
+    """Sets up the logging configuration to output to the console."""
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s [%(levelname)s] %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+        handlers=[logging.StreamHandler()]
+    )
+
+def parse_args():
+    """Parses command-line arguments."""
+    parser = argparse.ArgumentParser(description="Extract features and compute distribution metrics for optimized 3D meshes.")
+    
+    # Paths and folders
+    parser.add_argument("--base_dir", type=str, default="/scratch/cvlab/home/seiler/physiopt_new", help="Base directory of the project")
+    parser.add_argument("--experiment_folder", type=str, default="table_experiment", help="Name of the experiment folder")
+    parser.add_argument("--model_folder", type=str, default="gd_physiopt_64_180", help="Name of the subfolder containing optimized meshes")
+    
+    # Extraction parameters
+    parser.add_argument("--max_meshes", type=int, default=9, help="Maximum number of 'decrease' meshes per instance to process")
+    parser.add_argument("--num_points", type=int, default=2048, help="Number of sample points for PointNet extraction")
+    parser.add_argument("--seed", type=int, default=42, help="Random seed for reproducibility")
+    
+    # Debug/Testing
+    parser.add_argument("--test_mode", action="store_true", help="If set, only runs on hardcoded test instances instead of the full folder")
+    
+    return parser.parse_args()
+
+def main():
+    args = parse_args()
+    setup_logging()
+    
+    logging.info("Starting feature extraction and metric computation...")
+    logging.info(f"Experiment: {args.experiment_folder} | Model Folder: {args.model_folder}")
+
+    # Set random seeds
+    torch.manual_seed(args.seed)
+    torch.cuda.manual_seed(args.seed)
+
+    # Initialize models
+    logging.info("Loading feature extraction models...")
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    logging.info(f"Using device: {device}")
+    
+    model_point = PointNetExtractor().to(device)
+    model_dino = DINOv2Extractor().to(device)
+    model_inception = InceptionV3Extractor().to(device)
+    
+    models = {
+        "pointE": model_point, 
+        "inception": model_inception, 
+        "dino": model_dino
+    }
+
+    # Setup paths
+    path_folder_experiment = os.path.join(args.base_dir, "output", "hunyuan_gen", args.experiment_folder)
+    metrics_path_dir = os.path.join(args.base_dir, "metrics", "hunyuan_gen", args.experiment_folder)
+    
+    os.makedirs(metrics_path_dir, exist_ok=True)
+
+    # Determine instances to process
+    if args.test_mode:
+        logging.info("Running in TEST MODE. Only processing specific test instances.")
+        instance_list = ["table_0_test", "table_1_test"]
+    else:
+        if not os.path.exists(path_folder_experiment):
+            logging.error(f"Experiment folder not found: {path_folder_experiment}")
+            return
+        instance_list = sorted([d for d in os.listdir(path_folder_experiment) if os.path.isdir(os.path.join(path_folder_experiment, d))])
+    
+    logging.info(f"Found {len(instance_list)} instances to process.")
+
+    # Data structures to hold features
+    global_features = {"pointE": [], "inception": [], "dino": []}
+    number_data = [0 for _ in range(args.max_meshes)]
+
+    # Feature Extraction Loop
+    for instance in tqdm(instance_list, desc="Processing instances"):
+        mesh_folder = os.path.join(path_folder_experiment, instance, args.model_folder)
+        
+        if not os.path.exists(mesh_folder):
+            logging.warning(f"Mesh folder missing for instance {instance}. Skipping...")
+            continue
+
+        instance_features = {"pointE": [], "inception": [], "dino": []}
+        
+        # Get sorted list of decrease meshes
+        decrease_meshes = sorted([m for m in os.listdir(mesh_folder) if m.startswith('decrease') and m.endswith('.obj')])
+        
+        for i, mesh_filename in enumerate(decrease_meshes):
+            if i >= args.max_meshes:
+                break # Do not exceed max expected meshes
+                
+            mesh_path = os.path.join(mesh_folder, mesh_filename)
+            mesh = trimesh.load(mesh_path)
+            number_data[i] += 1
+            
+            with torch.no_grad():
+                features = extract_features_step(mesh, models, {"SamplePoints": args.num_points}, device)
+                instance_features["pointE"].append(features["pointE"])
+                instance_features["inception"].append(features["inception"])
+                instance_features["dino"].append(features["dino"])
+
+        # Padding with zeros if fewer meshes were found than expected
+        for k in ["pointE", "inception", "dino"]:
+            if len(instance_features[k]) == 0:
+                logging.warning(f"No features extracted for {k} in instance {instance}.")
+                continue
+                
+            dim = instance_features[k][0].shape
+            while len(instance_features[k]) < args.max_meshes:
+                instance_features[k].append(torch.zeros(dim, dtype=torch.float32).to(device))
+                
+            # Stack features for this instance and append to global tracking
+            instance_features[k] = torch.stack(instance_features[k])
+            global_features[k].append(instance_features[k])
+
+    # Computing Global Metrics
+    distribution_metrics = {}
+    metric_map = [
+        ("pointE", os.path.join(metrics_path_dir, "pointnetE_features.npy")),
+        ("inception", os.path.join(metrics_path_dir, "inceptionv3_features.npy")),
+        ("dino", os.path.join(metrics_path_dir, "dinov2_vits14_features.npy"))
+    ]
+
+    logging.info("Starting global metrics computation...")
+    for feat_name, spec_key_path in metric_map:
+        if not global_features[feat_name]:
+            logging.warning(f"No global features collected for {feat_name}. Skipping metrics.")
+            continue
+            
+        logging.info(f"Computing global metrics for {feat_name}...")
+        try:
+            res = compute_final_distribution_metrics(
+                global_features[feat_name], 
+                spec_key_path,
+                feat_name
+            )
+            distribution_metrics.update(res)
+        except Exception as e:
+            logging.error(f"Failed to compute metrics for {feat_name}: {e}")
+
+    # Save Results
+    distribution_metrics["number_data"] = number_data
+    output_json = os.path.join(metrics_path_dir, "metrics.json")
+    
+    with open(output_json, "w") as f:
+        json.dump(distribution_metrics, f, indent=4)
+        
+    logging.info(f"Successfully saved metrics to: {output_json}")
+    logging.info("Done!")
+
+if __name__ == "__main__":
+    main()

cfd_workflow_20261012/_seiler_ref/physiopt_new_scripts/force_web_ui.py

@@ -0,0 +1,733 @@
+import argparse
+import hashlib
+import json
+import os
+import re
+import shutil
+
+import numpy as np
+import gradio as gr
+import trimesh
+
+POINT_PREVIEW_MAX = 12000
+POINT_PREVIEW_SIZE_RATIO = 0.004
+ROTATE_X_CCW_90 = trimesh.transformations.rotation_matrix(
+    np.deg2rad(270.0), [1.0, 0.0, 0.0]
+)
+
+
+def _normalize_out_path(out_path: str) -> str:
+    out_path = (out_path or "").strip()
+    if not out_path:
+        out_path = "force_config.json"
+    if out_path.endswith(os.sep) or os.path.isdir(out_path):
+        out_path = os.path.join(out_path, "force_config.json")
+    return out_path
+
+
+def _parse_force_lines(text: str):
+    forces = []
+    for raw_line in (text or "").splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith("#"):
+            continue
+        parts = [p for p in re.split(r"[,\s]+", line) if p]
+        if len(parts) != 3:
+            continue
+        try:
+            vec = [float(v) for v in parts]
+        except Exception:
+            continue
+        forces.append(vec)
+    return forces
+
+
+def _save_config(
+    out_path: str,
+    fx: float,
+    fy: float,
+    fz: float,
+    extra_forces_text: str,
+    mode: str,
+    top_percent: float,
+    hr_min: float,
+    hr_max: float,
+    bx0: float,
+    bx1: float,
+    by0: float,
+    by1: float,
+    bz0: float,
+    bz1: float,
+    brx0: float,
+    brx1: float,
+    bry0: float,
+    bry1: float,
+    brz0: float,
+    brz1: float,
+    force_entries,
+):
+    out_path = _normalize_out_path(out_path)
+    os.makedirs(os.path.dirname(out_path) or ".", exist_ok=True)
+
+    force_entries = list(force_entries or [])
+    if force_entries:
+        entries = force_entries
+    else:
+        entries = [
+            _build_force_entry(
+                fx,
+                fy,
+                fz,
+                extra_forces_text,
+                mode,
+                top_percent,
+                hr_min,
+                hr_max,
+                bx0,
+                bx1,
+                by0,
+                by1,
+                bz0,
+                bz1,
+                brx0,
+                brx1,
+                bry0,
+                bry1,
+                brz0,
+                brz1,
+            )
+        ]
+
+    all_forces = _flatten_entry_forces(entries)
+
+    if len(entries) == 1:
+        cfg = dict(entries[0])
+    else:
+        cfg = {"force_entries": entries}
+        if len(all_forces) > 1:
+            cfg["forces"] = all_forces
+            cfg["force"] = [float(sum(v[i] for v in all_forces)) for i in range(3)]
+        elif len(all_forces) == 1:
+            cfg["force"] = all_forces[0]
+
+    with open(out_path, "w") as f:
+        json.dump(cfg, f, indent=2)
+
+    cmd = f"python scripts/viewer_hunyuan_web_alternate.py --latents <latents.pt> --use_physics --force_config {out_path}"
+    return f"Saved to {out_path}", json.dumps(cfg, indent=2), cmd
+
+
+def _toggle_groups(mode: str):
+    return (
+        gr.update(visible=mode == "top_percent"),
+        gr.update(visible=mode == "height_ratio"),
+        gr.update(visible=mode == "bbox_abs"),
+        gr.update(visible=mode == "bbox_ratio"),
+    )
+
+
+def _build_force_entry(
+    fx: float,
+    fy: float,
+    fz: float,
+    extra_forces_text: str,
+    mode: str,
+    top_percent: float,
+    hr_min: float,
+    hr_max: float,
+    bx0: float,
+    bx1: float,
+    by0: float,
+    by1: float,
+    bz0: float,
+    bz1: float,
+    brx0: float,
+    brx1: float,
+    bry0: float,
+    bry1: float,
+    brz0: float,
+    brz1: float,
+):
+    base_force = [float(fx), float(fy), float(fz)]
+    extra_forces = _parse_force_lines(extra_forces_text)
+    forces = []
+    base_nonzero = any(abs(v) > 0 for v in base_force)
+    if base_nonzero or not extra_forces:
+        forces.append(base_force)
+    forces.extend(extra_forces)
+
+    entry = {}
+    if len(forces) > 1:
+        entry["forces"] = forces
+        entry["force"] = [float(sum(v[i] for v in forces)) for i in range(3)]
+    else:
+        entry["force"] = forces[0]
+
+    if mode == "global":
+        entry["force_region_mode"] = "global"
+        entry["global_loading"] = True
+    elif mode == "top_percent":
+        entry["force_region_mode"] = "top_percent"
+        entry["force_top_percent"] = float(top_percent)
+    elif mode == "height_ratio":
+        entry["force_region_mode"] = "height_ratio"
+        entry["seat_height_min_ratio"] = float(hr_min)
+        entry["seat_height_max_ratio"] = float(hr_max)
+    elif mode == "bbox_abs":
+        entry["force_region_mode"] = "bbox"
+        entry["force_bbox"] = [
+            float(bx0),
+            float(bx1),
+            float(by0),
+            float(by1),
+            float(bz0),
+            float(bz1),
+        ]
+    elif mode == "bbox_ratio":
+        entry["force_region_mode"] = "bbox"
+        entry["force_bbox_ratio"] = [
+            float(brx0),
+            float(brx1),
+            float(bry0),
+            float(bry1),
+            float(brz0),
+            float(brz1),
+        ]
+    return entry
+
+
+def _flatten_entry_forces(entries):
+    all_forces = []
+    for entry in entries:
+        if not isinstance(entry, dict):
+            continue
+        if "forces" in entry and isinstance(entry["forces"], list):
+            all_forces.extend(entry["forces"])
+        elif "force" in entry:
+            all_forces.append(entry["force"])
+    return all_forces
+
+
+def _add_force_entry(
+    force_entries,
+    fx: float,
+    fy: float,
+    fz: float,
+    extra_forces_text: str,
+    mode: str,
+    top_percent: float,
+    hr_min: float,
+    hr_max: float,
+    bx0: float,
+    bx1: float,
+    by0: float,
+    by1: float,
+    bz0: float,
+    bz1: float,
+    brx0: float,
+    brx1: float,
+    bry0: float,
+    bry1: float,
+    brz0: float,
+    brz1: float,
+):
+    entries = list(force_entries or [])
+    entry = _build_force_entry(
+        fx,
+        fy,
+        fz,
+        extra_forces_text,
+        mode,
+        top_percent,
+        hr_min,
+        hr_max,
+        bx0,
+        bx1,
+        by0,
+        by1,
+        bz0,
+        bz1,
+        brx0,
+        brx1,
+        bry0,
+        bry1,
+        brz0,
+        brz1,
+    )
+    entries.append(entry)
+    preview = json.dumps(entries, indent=2)
+    status = f"✅ Added load location #{len(entries)}"
+    return entries, preview, status
+
+
+def _clear_force_entries():
+    return [], "[]", "🧹 Cleared all load locations"
+
+
+def _copy_to_tmp(mesh_path: str) -> str:
+    abs_path = os.path.abspath(os.path.expanduser(mesh_path))
+    stat = os.stat(abs_path)
+    key = f"{abs_path}|{stat.st_size}|{stat.st_mtime_ns}"
+    digest = hashlib.sha256(key.encode("utf-8")).hexdigest()[:16]
+    tmp_dir = os.path.join("./tmp", "force_web_ui_cache")
+    os.makedirs(tmp_dir, exist_ok=True)
+    dst_name = f"{digest}_{os.path.basename(abs_path)}"
+    dst_path = os.path.join(tmp_dir, dst_name)
+    if not os.path.exists(dst_path):
+        shutil.copy2(abs_path, dst_path)
+    return dst_path
+
+
+def _prepare_preview_mesh(mesh, mesh_path: str, rotated: bool):
+    """Export preview mesh to ./tmp as GLB (fallback to original file)."""
+    abs_path = os.path.abspath(os.path.expanduser(mesh_path))
+    stat = os.stat(abs_path)
+    key = f"{abs_path}|{stat.st_size}|{stat.st_mtime_ns}|rotated={int(bool(rotated))}|preview_v1"
+    digest = hashlib.sha256(key.encode("utf-8")).hexdigest()[:16]
+    tmp_dir = os.path.join("./tmp", "force_web_ui_cache")
+    os.makedirs(tmp_dir, exist_ok=True)
+    glb_path = os.path.join(tmp_dir, f"{digest}.glb")
+    if not os.path.exists(glb_path):
+        try:
+            mesh_to_export = mesh
+            if isinstance(mesh, trimesh.Scene):
+                geoms = [g for g in mesh.dump() if isinstance(g, trimesh.Trimesh)]
+                if len(geoms) > 0:
+                    mesh_to_export = trimesh.util.concatenate(geoms)
+            mesh_to_export.export(glb_path)
+        except Exception:
+            return _copy_to_tmp(mesh_path), "⚠️ Preview GLB export failed; using the original file instead"
+    return glb_path, None
+
+
+def _reduce_faces(mesh: trimesh.Trimesh, target_faces: int) -> trimesh.Trimesh:
+    if not isinstance(mesh, trimesh.Trimesh) or mesh.faces is None:
+        return mesh
+    face_count = int(mesh.faces.shape[0])
+    if face_count <= target_faces:
+        return mesh
+    idx = np.linspace(0, face_count - 1, target_faces, dtype=np.int64)
+    faces = mesh.faces[idx]
+    mesh_small = trimesh.Trimesh(vertices=mesh.vertices, faces=faces, process=False)
+    try:
+        mesh_small.remove_unreferenced_vertices()
+    except Exception:
+        pass
+    return mesh_small
+
+
+def _extract_points_and_mesh(loaded):
+    if loaded is None:
+        return None, None
+    if isinstance(loaded, trimesh.Trimesh):
+        pts = loaded.vertices if hasattr(loaded, "vertices") else None
+        return (np.asarray(pts) if pts is not None else None), loaded
+    if isinstance(loaded, trimesh.points.PointCloud):
+        pts = loaded.vertices if hasattr(loaded, "vertices") else loaded.points
+        return (np.asarray(pts) if pts is not None else None), None
+    if isinstance(loaded, trimesh.Scene):
+        meshes = []
+        points = []
+        for geom in loaded.dump():
+            if isinstance(geom, trimesh.Trimesh):
+                meshes.append(geom)
+            elif isinstance(geom, trimesh.points.PointCloud):
+                pts = geom.vertices if hasattr(geom, "vertices") else geom.points
+                if pts is not None:
+                    points.append(np.asarray(pts))
+        if meshes:
+            mesh = trimesh.util.concatenate(meshes)
+            pts = mesh.vertices if hasattr(mesh, "vertices") else None
+            return (np.asarray(pts) if pts is not None else None), mesh
+        if points:
+            return np.concatenate(points, axis=0), None
+    return None, None
+
+
+def _rotate_points_and_mesh(points, mesh, enable_rotation: bool):
+    if not enable_rotation:
+        return points, mesh
+
+    rot = np.asarray(ROTATE_X_CCW_90, dtype=np.float64)
+
+    rotated_points = None
+    if points is not None:
+        rotated_points = trimesh.transform_points(np.asarray(points, dtype=np.float64), rot)
+
+    rotated_mesh = None
+    if mesh is not None:
+        rotated_mesh = mesh.copy()
+        rotated_mesh.apply_transform(rot)
+
+    return rotated_points, rotated_mesh
+
+
+def _make_preview_mesh_from_points(points: np.ndarray):
+    if points is None or len(points) == 0:
+        return None, "⚠️ The point cloud is empty and cannot be previewed"
+    points = np.asarray(points, dtype=np.float32)
+    total = int(points.shape[0])
+    if total > POINT_PREVIEW_MAX:
+        idx = np.linspace(0, total - 1, POINT_PREVIEW_MAX, dtype=np.int64)
+        pts = points[idx]
+        sample_note = f" (sampled {POINT_PREVIEW_MAX}/{total})"
+    else:
+        pts = points
+        sample_note = f" ({total} pts)"
+    min_b = points.min(axis=0)
+    max_b = points.max(axis=0)
+    max_range = float(np.max(max_b - min_b))
+    if not np.isfinite(max_range) or max_range <= 0:
+        max_range = 1.0
+    point_size = max(max_range * POINT_PREVIEW_SIZE_RATIO, 1e-4)
+    try:
+        base = trimesh.creation.box(extents=[point_size, point_size, point_size])
+        v = base.vertices
+        f = base.faces
+        num = int(pts.shape[0])
+        verts = (v[None, :, :] + pts[:, None, :]).reshape(-1, 3)
+        faces = (f[None, :, :] + (np.arange(num) * len(v))[:, None, None]).reshape(-1, 3)
+        cloud_mesh = trimesh.Trimesh(vertices=verts, faces=faces, process=False)
+        cloud_mesh.visual.face_colors = [120, 120, 120, 100]
+        return cloud_mesh, f"✅ Point-cloud preview{sample_note}, point size≈{point_size:.4f}"
+    except Exception as e:
+        extents = np.maximum(max_b - min_b, 1e-6)
+        center = (min_b + max_b) * 0.5
+        transform = trimesh.transformations.translation_matrix(center)
+        box = trimesh.creation.box(extents=extents, transform=transform)
+        box.visual.face_colors = [160, 160, 160, 60]
+        return box, f"⚠️ Point-cloud preview failed; using a bounding box instead: {e}"
+
+
+def _load_mesh(mesh_path: str, z_up: bool):
+    mesh_path = (mesh_path or "").strip()
+    if not mesh_path:
+        return "⚠️ Please enter a mesh path", "", None, None, None
+    if not os.path.exists(mesh_path):
+        return f"⚠️ Path does not exist: {mesh_path}", "", None, None, None
+    try:
+        loaded = trimesh.load(mesh_path, force="scene")
+        points, mesh = _extract_points_and_mesh(loaded)
+        if points is None or len(points) == 0:
+            return "⚠️ The mesh is empty or failed to load", "", None, None, None
+        points, mesh = _rotate_points_and_mesh(points, mesh, enable_rotation=bool(z_up))
+        status_prefix = "✅ Mesh loaded"
+        preview_note = None
+        target_faces = 100000
+        if isinstance(mesh, trimesh.Trimesh) and mesh.faces is not None:
+            face_count = int(mesh.faces.shape[0])
+            if face_count == 0:
+                preview_mesh, preview_note = _make_preview_mesh_from_points(points)
+                mesh = preview_mesh
+                status_prefix = "✅ Point cloud loaded"
+            elif face_count > target_faces:
+                try:
+                    mesh = mesh.simplify_quadratic_decimation(target_faces)
+                    status_prefix += f" (simplified: {face_count} -> {mesh.faces.shape[0]} faces)"
+                except Exception:
+                    mesh = _reduce_faces(mesh, target_faces)
+                    if hasattr(mesh, "faces") and mesh.faces is not None:
+                        status_prefix += f" (sample-based reduction: {face_count} -> {mesh.faces.shape[0]} faces)"
+                    else:
+                        status_prefix += f" (⚠️ simplification failed, faces={face_count})"
+        elif mesh is None:
+            preview_mesh, preview_note = _make_preview_mesh_from_points(points)
+            mesh = preview_mesh
+            status_prefix = "✅ Point cloud loaded"
+
+        min_b = points.min(axis=0)
+        max_b = points.max(axis=0)
+        size = max_b - min_b
+        info = (
+            f"min: [{min_b[0]:.4f}, {min_b[1]:.4f}, {min_b[2]:.4f}]\n"
+            f"max: [{max_b[0]:.4f}, {max_b[1]:.4f}, {max_b[2]:.4f}]\n"
+            f"size: [{size[0]:.4f}, {size[1]:.4f}, {size[2]:.4f}]"
+        )
+        bbox = [float(min_b[0]), float(max_b[0]), float(min_b[1]), float(max_b[1]), float(min_b[2]), float(max_b[2])]
+        preview_path, warn = _prepare_preview_mesh(mesh, mesh_path, rotated=bool(z_up))
+        status_parts = [status_prefix]
+        if z_up:
+            status_parts.append("↻ Rotated 90 degrees counterclockwise around the +X axis")
+        if warn is not None:
+            status_parts.append(warn)
+        if preview_note is not None:
+            status_parts.append(preview_note)
+        status = "\n".join(status_parts)
+        return status, info, preview_path, bbox, preview_path
+    except Exception as e:
+        return f"⚠️ Load failed: {e}", "", None, None, None
+
+
+def _set_bbox_abs_from_bounds(bounds):
+    if not bounds or len(bounds) != 6:
+        return [gr.update() for _ in range(6)]
+    return [bounds[0], bounds[1], bounds[2], bounds[3], bounds[4], bounds[5]]
+
+
+def _bbox_from_ratio(bounds, ratio):
+    if not bounds or len(bounds) != 6 or not ratio or len(ratio) != 6:
+        return None
+    x0, x1, y0, y1, z0, z1 = [float(v) for v in bounds]
+    rx0, rx1, ry0, ry1, rz0, rz1 = [float(v) for v in ratio]
+    return [
+        x0 + rx0 * (x1 - x0),
+        x0 + rx1 * (x1 - x0),
+        y0 + ry0 * (y1 - y0),
+        y0 + ry1 * (y1 - y0),
+        z0 + rz0 * (z1 - z0),
+        z0 + rz1 * (z1 - z0),
+    ]
+
+
+def _preview_bbox(
+    preview_path: str,
+    bounds,
+    mode: str,
+    bx0: float,
+    bx1: float,
+    by0: float,
+    by1: float,
+    bz0: float,
+    bz1: float,
+    brx0: float,
+    brx1: float,
+    bry0: float,
+    bry1: float,
+    brz0: float,
+    brz1: float,
+):
+    if not preview_path or not os.path.exists(preview_path):
+        return gr.update(), "⚠️ Please load a mesh first"
+    mode = (mode or "").lower()
+    if mode not in ("bbox_abs", "bbox_ratio"):
+        return gr.update(), "⚠️ Preview is only available in bbox mode"
+    if mode == "bbox_ratio":
+        bbox = _bbox_from_ratio(bounds, [brx0, brx1, bry0, bry1, brz0, brz1])
+        if bbox is None:
+            return gr.update(), "⚠️ bbox_ratio is missing bounds or parameters"
+    else:
+        bbox = [bx0, bx1, by0, by1, bz0, bz1]
+    x0, x1 = sorted([float(bbox[0]), float(bbox[1])])
+    y0, y1 = sorted([float(bbox[2]), float(bbox[3])])
+    z0, z1 = sorted([float(bbox[4]), float(bbox[5])])
+    if x1 - x0 <= 0 or y1 - y0 <= 0 or z1 - z0 <= 0:
+        return gr.update(), "⚠️ Invalid bbox size"
+
+    try:
+        base = trimesh.load(preview_path, force="scene")
+        scene = base if isinstance(base, trimesh.Scene) else trimesh.Scene(base)
+        center = np.array([(x0 + x1) / 2, (y0 + y1) / 2, (z0 + z1) / 2], dtype=np.float64)
+        extents = np.array([x1 - x0, y1 - y0, z1 - z0], dtype=np.float64)
+        transform = trimesh.transformations.translation_matrix(center)
+        box = trimesh.creation.box(extents=extents, transform=transform)
+        box.visual.face_colors = [255, 0, 0, 60]
+        scene.add_geometry(box, node_name="bbox")
+
+        stat = os.stat(preview_path)
+        key = f"{preview_path}|{stat.st_size}|{stat.st_mtime_ns}|{x0},{x1},{y0},{y1},{z0},{z1}"
+        digest = hashlib.sha256(key.encode("utf-8")).hexdigest()[:16]
+        tmp_dir = os.path.join("./tmp", "force_web_ui_cache")
+        os.makedirs(tmp_dir, exist_ok=True)
+        out_path = os.path.join(tmp_dir, f"bbox_{digest}.glb")
+        scene.export(out_path)
+        return out_path, "✅ Updated bbox preview"
+    except Exception as e:
+        return gr.update(), f"⚠️ Bbox preview failed: {e}"
+
+
+def build_ui(default_out: str, z_up: bool):
+    with gr.Blocks(title="Force Config UI") as demo:
+        gr.Markdown(
+            "Set force vector(s) (Y-up) and region. "
+            "Use 'Add Force Entry' to create multiple locations; "
+            "Save JSON will use entries if any exist."
+        )
+
+        mesh_bounds_state = gr.State(None)
+        mesh_preview_state = gr.State(None)
+        force_entries_state = gr.State([])
+
+        out_path = gr.Textbox(label="Output JSON Path", value=default_out)
+        mesh_path = gr.Textbox(label="Mesh Path (server)", placeholder="/path/to/mesh.obj")
+        with gr.Row():
+            load_mesh_btn = gr.Button("Load Mesh")
+            fill_bbox_btn = gr.Button("Use Mesh Bounds for BBox")
+        mesh_status = gr.Textbox(label="Mesh Status", interactive=False)
+        mesh_bounds = gr.Textbox(label="Mesh Bounds", interactive=False)
+        mesh_view = gr.Model3D(label="Mesh Preview")
+        bbox_status = gr.Textbox(label="BBox Preview Status", interactive=False)
+
+        if z_up:
+            with gr.Row():
+                fx = gr.Number(label="Fx (N)", value=0.0)
+                fy = gr.Number(label="Fy (N)", value=0.0)
+                fz = gr.Number(label="Fz (N)", value=-100000.0)
+        else:
+            with gr.Row():
+                fx = gr.Number(label="Fx (N)", value=0.0)
+                fy = gr.Number(label="Fy (N)", value=-100000.0)
+                fz = gr.Number(label="Fz (N)", value=0.0)
+        extra_forces = gr.Textbox(
+            label="Extra Forces (one per line: fx fy fz)",
+            placeholder="0 0 -500\n100 0 0",
+            lines=3,
+        )
+
+        mode = gr.Radio(
+            ["global", "top_percent", "height_ratio", "bbox_abs", "bbox_ratio"],
+            value="top_percent",
+            label="Region Mode",
+        )
+
+        with gr.Group(visible=True) as top_group:
+            top_percent = gr.Slider(0.01, 0.5, value=0.05, step=0.01, label="Top Percent")
+
+        with gr.Group(visible=False) as height_group:
+            hr_min = gr.Slider(0.0, 1.0, value=0.3, step=0.01, label="Height Min Ratio")
+            hr_max = gr.Slider(0.0, 1.0, value=0.5, step=0.01, label="Height Max Ratio")
+
+        with gr.Group(visible=False) as bbox_abs_group:
+            gr.Markdown("BBox (abs) order: x_min, x_max, y_min, y_max, z_min, z_max")
+            with gr.Row():
+                bx0 = gr.Number(label="x_min", value=-0.2)
+                bx1 = gr.Number(label="x_max", value=0.2)
+                by0 = gr.Number(label="y_min", value=0.2)
+                by1 = gr.Number(label="y_max", value=0.4)
+                bz0 = gr.Number(label="z_min", value=-0.2)
+                bz1 = gr.Number(label="z_max", value=0.2)
+
+        with gr.Group(visible=False) as bbox_ratio_group:
+            gr.Markdown("BBox (ratio 0-1) order: x_min, x_max, y_min, y_max, z_min, z_max")
+            with gr.Row():
+                brx0 = gr.Slider(0.0, 1.0, value=0.4, step=0.01, label="x_min")
+                brx1 = gr.Slider(0.0, 1.0, value=0.6, step=0.01, label="x_max")
+                bry0 = gr.Slider(0.0, 1.0, value=0.4, step=0.01, label="y_min")
+                bry1 = gr.Slider(0.0, 1.0, value=0.6, step=0.01, label="y_max")
+                brz0 = gr.Slider(0.0, 1.0, value=0.4, step=0.01, label="z_min")
+                brz1 = gr.Slider(0.0, 1.0, value=0.6, step=0.01, label="z_max")
+
+        save_btn = gr.Button("Save JSON", variant="primary")
+        add_force_btn = gr.Button("Add Force Entry")
+        clear_force_btn = gr.Button("Clear Force Entries")
+        preview_bbox_btn = gr.Button("Preview BBox")
+        status = gr.Textbox(label="Status")
+        force_entries_preview = gr.Code(label="Force Entries", language="json", value="[]")
+        preview = gr.Code(label="JSON Preview", language="json")
+        cmd = gr.Textbox(label="Command Preview")
+
+        mode.change(
+            _toggle_groups,
+            inputs=mode,
+            outputs=[top_group, height_group, bbox_abs_group, bbox_ratio_group],
+        )
+        load_mesh_btn.click(
+            _load_mesh,
+            inputs=[mesh_path, gr.State(z_up)],
+            outputs=[mesh_status, mesh_bounds, mesh_view, mesh_bounds_state, mesh_preview_state],
+        )
+        fill_bbox_btn.click(
+            _set_bbox_abs_from_bounds,
+            inputs=[mesh_bounds_state],
+            outputs=[bx0, bx1, by0, by1, bz0, bz1],
+        )
+        preview_bbox_btn.click(
+            _preview_bbox,
+            inputs=[
+                mesh_preview_state,
+                mesh_bounds_state,
+                mode,
+                bx0,
+                bx1,
+                by0,
+                by1,
+                bz0,
+                bz1,
+                brx0,
+                brx1,
+                bry0,
+                bry1,
+                brz0,
+                brz1,
+            ],
+            outputs=[mesh_view, bbox_status],
+        )
+
+        add_force_btn.click(
+            _add_force_entry,
+            inputs=[
+                force_entries_state,
+                fx,
+                fy,
+                fz,
+                extra_forces,
+                mode,
+                top_percent,
+                hr_min,
+                hr_max,
+                bx0,
+                bx1,
+                by0,
+                by1,
+                bz0,
+                bz1,
+                brx0,
+                brx1,
+                bry0,
+                bry1,
+                brz0,
+                brz1,
+            ],
+            outputs=[force_entries_state, force_entries_preview, status],
+        )
+        clear_force_btn.click(
+            _clear_force_entries,
+            inputs=[],
+            outputs=[force_entries_state, force_entries_preview, status],
+        )
+
+        save_btn.click(
+            _save_config,
+            inputs=[
+                out_path,
+                fx,
+                fy,
+                fz,
+                extra_forces,
+                mode,
+                top_percent,
+                hr_min,
+                hr_max,
+                bx0,
+                bx1,
+                by0,
+                by1,
+                bz0,
+                bz1,
+                brx0,
+                brx1,
+                bry0,
+                bry1,
+                brz0,
+                brz1,
+                force_entries_state,
+            ],
+            outputs=[status, preview, cmd],
+        )
+    return demo
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Force config web UI")
+    parser.add_argument("--out", type=str, default="force_config.json", help="Output JSON path")
+    parser.add_argument("--server_name", type=str, default="0.0.0.0", help="Gradio server name")
+    parser.add_argument("--server_port", type=int, default=7860, help="Gradio server port")
+    parser.add_argument("--share", action="store_true", help="Enable Gradio share link")
+    parser.add_argument("--z_up", action="store_true", help="Enable z_up mode")
+    args = parser.parse_args()
+
+    demo = build_ui(args.out, args.z_up)
+    demo.launch(server_name=args.server_name, server_port=args.server_port, share=args.share)
+
+
+if __name__ == "__main__":
+    main()

cfd_workflow_20261012/_seiler_ref/physiopt_new_scripts/sample_hunyuan.py

@@ -0,0 +1,222 @@
+"""
+Hunyuan3D-2.1 Shape Generation Script
+Generate a 3D shape and save latent tokens for later physics optimization.
+"""
+
+# python scripts/sample_hunyuan.py --image /scratch/cvlab/home/seiler/physiopt_new/input/new_york.png --out_folder /scratch/cvlab/home/seiler/physiopt_new/output/hunyuan_gen/new_york
+
+import os
+# os.environ['TORCH_HOME'] = '/mnt/cvlab/scratch/cvlab/home/hantzhan/.torch'
+import sys
+
+# Add Hunyuan3D-2.1 to the Python path.
+hunyuan_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "../Hunyuan3D-2.1"))
+print(hunyuan_path)
+if os.path.exists(hunyuan_path):
+    sys.path.insert(0, hunyuan_path)
+    print(f"✅ Added Hunyuan3D-2.1 to the Python path: {hunyuan_path}")
+else:
+    print(f"⚠️  Warning: Hunyuan3D-2.1 path does not exist: {hunyuan_path}")
+    print(f"   Please make sure Hunyuan3D-2.1 has been cloned to the correct location")
+
+sys.path.append("..")
+
+import torch
+import trimesh
+import numpy as np
+from PIL import Image
+from argparse import ArgumentParser
+
+try:
+    from hy3dgen.rembg import BackgroundRemover
+    from hy3dgen.shapegen import Hunyuan3DDiTFlowMatchingPipeline
+    from hy3dgen.shapegen.models.autoencoders import ShapeVAE
+except ImportError as e:
+    print(f"❌ Failed to import the Hunyuan3D modules: {e}")
+    print(f"\nPlease set up Hunyuan3D-2.1 with the following steps:")
+    print(f"1. cd {os.path.dirname(hunyuan_path)}")
+    print(f"2. git clone https://github.com/Tencent/Hunyuan3D-2.git Hunyuan3D-2.1")
+    print(f"3. cd Hunyuan3D-2.1")
+    print(f"4. pip install -e .")
+    sys.exit(1)
+
+
+if __name__ == "__main__":
+    parser = ArgumentParser()
+    parser.add_argument("--image", type=str, required=True, help="Input image path")
+    parser.add_argument("--out_folder", type=str, default="../out/hunyuan_tmp", help="Output directory")
+    parser.add_argument("--seed", type=int, default=42, help="Random seed (base value)")
+    parser.add_argument("--num_results", type=int, default=1, help="Number of generated results (different seeds)")
+    parser.add_argument("--num_inference_steps", type=int, default=50, help="Number of inference steps")
+    parser.add_argument("--guidance_scale", type=float, default=7.5, help="CFG strength")
+    parser.add_argument("--model_path", type=str, default="tencent/Hunyuan3D-2.1", help="Model path (using v2.1)")
+    parser.add_argument("--subfolder", type=str, default="hunyuan3d-dit-v2-1", help="Model subfolder")
+    parser.add_argument("--use_safetensors", action="store_true", help="Use safetensors format (default is ckpt)")
+    parser.add_argument("--octree_resolution", type=int, default=384, help="Octree resolution (higher is finer but slower)")
+    parser.add_argument("--mc_level", type=float, default=0, help="Marching Cubes threshold")
+    args = parser.parse_args()
+    
+    # Create the output directory.
+    os.makedirs(args.out_folder, exist_ok=True)
+    
+    # Print configuration details.
+    print("\n" + "="*60)
+    print("Hunyuan3D-2.1 configuration:")
+    print(f"  - Model: {args.model_path}/{args.subfolder}")
+    print(f"  - Model format: {'safetensors' if args.use_safetensors else 'checkpoint (.ckpt)'}")
+    print(f"  - Inference steps: {args.num_inference_steps} (recommended: 50-100)")
+    print(f"  - Result count: {args.num_results}")
+    print(f"  - CFG strength: {args.guidance_scale} (recommended: 7.0-10.0)")
+    print(f"  - Octree resolution: {args.octree_resolution} (recommended: 384-512)")
+    print(f"  - MC threshold: {args.mc_level:.6f}")
+    print("="*60 + "\n")
+    
+    # ==================== Load the model ====================
+    print("🔧 Loading the Hunyuan3D-2.1 model...")
+    print(f"   Model path: {args.model_path}")
+    print(f"   Subfolder: {args.subfolder}")
+    
+    try:
+        # Use the v2.1 model (newer and stronger).
+        # v2.1 uses the .ckpt format, so use_safetensors=False is required.
+        pipeline = Hunyuan3DDiTFlowMatchingPipeline.from_pretrained(
+            args.model_path,
+            subfolder=args.subfolder,
+            torch_dtype=torch.float16,
+            use_safetensors=args.use_safetensors
+        )
+        
+        if pipeline is None:
+            raise ValueError("Pipeline loading failed and returned None")
+        
+        print("   ✅ Pipeline loaded successfully")
+        
+        # Note: to() may not return self, so do not reassign pipeline.
+        pipeline.to('cuda')
+        print("   ✅ Model moved to CUDA (dtype: fp16)")
+        
+    except Exception as e:
+        print(f"\n❌ Model loading failed: {e}")
+        print(f"\nPossible causes:")
+        print(f"1. The model has not been downloaded yet - the first run fetches it from Hugging Face")
+        print(f"2. Network issues - make sure huggingface.co is reachable")
+        print(f"3. Insufficient disk space")
+        print(f"\nSuggested fixes:")
+        print(f"1. Set a Hugging Face token if the model requires one:")
+        print(f"   huggingface-cli login")
+        print(f"2. Or download the model manually:")
+        print(f"   git lfs install")
+        print(f"   git clone https://huggingface.co/tencent/Hunyuan3D-2.1")
+        print(f"   Then use --model_path ./Hunyuan3D-2.1 --subfolder hunyuan3d-dit-v2-1")
+        print(f"3. Or use the v2.0 model instead:")
+        print(f"   --model_path tencent/Hunyuan3D-2 --subfolder hunyuan3d-dit-v2-0")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+    
+    # Get the VAE for later mesh generation.
+    vae = pipeline.vae
+    print(f"   ✅ VAE acquired successfully")
+    
+    # ==================== Prepare the input image ====================
+    print(f"📷 Loading image: {args.image}")
+    image = Image.open(args.image).convert("RGBA")
+    
+    # If this is an RGB image, remove the background with rembg.
+    if image.mode == 'RGB':
+        print("   Removing background...")
+        rembg = BackgroundRemover()
+        image = rembg(image)
+    
+    # Save the processed image.
+    image.save(os.path.join(args.out_folder, "input_image.png"))
+    
+    # ==================== Generate the 3D shape ====================
+    print(f"🎨 Generating a 3D shape (steps={args.num_inference_steps}, cfg={args.guidance_scale})...")
+    num_results = max(1, int(args.num_results))
+    
+    for idx in range(num_results):
+        sample_seed = args.seed + idx
+        sample_out = args.out_folder if num_results == 1 else os.path.join(args.out_folder, f"sample_{idx:02d}")
+        os.makedirs(sample_out, exist_ok=True)
+        
+        if num_results > 1:
+            image.save(os.path.join(sample_out, "input_image.png"))
+        
+        print(f"\n=== Sample {idx+1}/{num_results} | seed={sample_seed} ===")
+    
+    # Set random seeds.
+        torch.manual_seed(sample_seed)
+        np.random.seed(sample_seed)
+    
+    # Use the simplified pipeline call, consistent with sample_hunyuan_simple.py.
+    # Step 1: generate and save latents.
+    latents = pipeline(
+        image=image,
+        num_inference_steps=args.num_inference_steps,
+        guidance_scale=args.guidance_scale,
+            generator=torch.Generator(device='cuda').manual_seed(sample_seed),
+        output_type='latent',  # Return latents only; do not decode to mesh yet.
+    )
+    
+    print("✅ Latent generation completed!")
+    
+    # ==================== Save latents for physics optimization ====================
+    latents_path = os.path.join(sample_out, "latents.pt")
+    
+    # Save latents and the image.
+    save_dict = {
+        'latents': latents.cpu() if isinstance(latents, torch.Tensor) else latents,
+        'image': np.array(image)
+    }
+    
+    torch.save(save_dict, latents_path)
+    print(f"✅ Saved latents to: {latents_path}")
+    if isinstance(latents, torch.Tensor):
+        print(f"   - Latents shape: {latents.shape}")
+        print(f"   - Latents range: [{latents.min().item():.3f}, {latents.max().item():.3f}]")
+    
+    # Step 2: decode latents to a mesh with _export().
+    print(f"🎭 Decoding latents into a mesh...")
+    print(f"   Using parameters: octree_resolution={args.octree_resolution}, mc_level={args.mc_level:.6f}")
+    mesh = pipeline._export(
+        latents,
+        output_type='trimesh',
+        box_v=1.01,
+        mc_level=args.mc_level,
+        num_chunks=20000,
+        octree_resolution=args.octree_resolution,
+        mc_algo='mc',
+        enable_pbar=True
+    )[0]
+    
+    print("✅ Decoding completed!")
+    
+    # ==================== Save the mesh ====================
+    mesh_path = os.path.join(sample_out, "generated_mesh.obj")
+    mesh.export(mesh_path)
+    print(f"💾 Saved mesh to: {mesh_path}")
+    
+    # Save GLB as well.
+    glb_path = os.path.join(sample_out, "generated_mesh.glb")
+    mesh.export(glb_path)
+    print(f"💾 Saved GLB to: {glb_path}")
+    
+    # ==================== Print summary statistics ====================
+    print("\n📊 Generation summary:")
+    print(f"   - Vertices: {len(mesh.vertices)}")
+    print(f"   - Faces: {len(mesh.faces)}")
+    if isinstance(latents, torch.Tensor):
+        print(f"   - Latent shape: {latents.shape}")
+        
+        # Free GPU memory.
+        del mesh
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+    
+    print(f"\n✅ All done! Outputs were saved to: {args.out_folder}")
+    if num_results == 1:
+        print(f"   - You can use latents.pt for physics optimization")
+        print(f"   - Run: python viewer_hunyuan_web.py --latents {latents_path}")
+    else:
+        print(f"   - Each sample is stored in its own sample_XX subdirectory")

cfd_workflow_20261012/_seiler_ref/physiopt_new_scripts/sample_hunyuan_from_folder.py

@@ -0,0 +1,223 @@
+"""
+Hunyuan3D-2.1 Shape Generation Script
+Generate a 3D shape and save latent tokens for later physics optimization.
+"""
+
+import os
+import sys
+import glob
+import logging
+import torch
+import trimesh
+import numpy as np
+from PIL import Image
+from argparse import ArgumentParser
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[logging.StreamHandler(sys.stdout)]
+)
+
+# Add Hunyuan3D-2.1 to the Python path.
+hunyuan_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "../Hunyuan3D-2.1"))
+
+if os.path.exists(hunyuan_path):
+    sys.path.insert(0, hunyuan_path)
+    logging.info(f"✅ Added Hunyuan3D-2.1 to the Python path: {hunyuan_path}")
+else:
+    logging.warning(f"⚠️  Hunyuan3D-2.1 path does not exist: {hunyuan_path}")
+    logging.warning("   Please make sure Hunyuan3D-2.1 has been cloned to the correct location")
+
+sys.path.append("..")
+
+try:
+    from hy3dgen.rembg import BackgroundRemover
+    from hy3dgen.shapegen import Hunyuan3DDiTFlowMatchingPipeline
+    from hy3dgen.shapegen.models.autoencoders import ShapeVAE
+except ImportError as e:
+    logging.error(f"❌ Failed to import the Hunyuan3D modules: {e}")
+    logging.info("\nPlease set up Hunyuan3D-2.1 with the following steps:")
+    logging.info(f"1. cd {os.path.dirname(hunyuan_path)}")
+    logging.info("2. git clone https://github.com/Tencent/Hunyuan3D-2.git Hunyuan3D-2.1")
+    logging.info("3. cd Hunyuan3D-2.1")
+    logging.info("4. pip install -e .")
+    sys.exit(1)
+
+
+if __name__ == "__main__":
+    parser = ArgumentParser()
+    parser.add_argument("--input", type=str, required=True, help="Input image path OR input folder path containing images")
+    parser.add_argument("--seed", type=int, default=42, help="Random seed (base value)")
+    parser.add_argument("--num_results", type=int, default=1, help="Number of generated results (different seeds)")
+    parser.add_argument("--num_inference_steps", type=int, default=50, help="Number of inference steps")
+    parser.add_argument("--guidance_scale", type=float, default=7.5, help="CFG strength")
+    parser.add_argument("--model_path", type=str, default="tencent/Hunyuan3D-2.1", help="Model path (using v2.1)")
+    parser.add_argument("--subfolder", type=str, default="hunyuan3d-dit-v2-1", help="Model subfolder")
+    parser.add_argument("--use_safetensors", action="store_true", help="Use safetensors format (default is ckpt)")
+    parser.add_argument("--octree_resolution", type=int, default=384, help="Octree resolution (higher is finer but slower)")
+    parser.add_argument("--mc_level", type=float, default=0, help="Marching Cubes threshold")
+    args = parser.parse_args()
+    
+    # Log configuration details
+    logging.info("="*60)
+    logging.info("Hunyuan3D-2.1 configuration:")
+    logging.info(f"  - Model: {args.model_path}/{args.subfolder}")
+    logging.info(f"  - Model format: {'safetensors' if args.use_safetensors else 'checkpoint (.ckpt)'}")
+    logging.info(f"  - Inference steps: {args.num_inference_steps}")
+    logging.info(f"  - Result count: {args.num_results}")
+    logging.info(f"  - CFG strength: {args.guidance_scale}")
+    logging.info(f"  - Octree resolution: {args.octree_resolution}")
+    logging.info(f"  - MC threshold: {args.mc_level:.6f}")
+    logging.info("="*60)
+    
+    # ==================== Load the model ====================
+    logging.info("🔧 Loading the Hunyuan3D-2.1 model...")
+    
+    try:
+        pipeline = Hunyuan3DDiTFlowMatchingPipeline.from_pretrained(
+            args.model_path,
+            subfolder=args.subfolder,
+            torch_dtype=torch.float16,
+            use_safetensors=args.use_safetensors
+        )
+        
+        if pipeline is None:
+            raise ValueError("Pipeline loading failed and returned None")
+        
+        logging.info("   ✅ Pipeline loaded successfully")
+        pipeline.to('cuda')
+        logging.info("   ✅ Model moved to CUDA (dtype: fp16)")
+        
+    except Exception as e:
+        logging.error(f"❌ Model loading failed: {e}")
+        import traceback
+        logging.error(traceback.format_exc())
+        sys.exit(1)
+    
+    vae = pipeline.vae
+    logging.info("   ✅ VAE acquired successfully")
+    
+    # Init Background Remover once (optimization)
+    logging.info("   🔧 Initializing Background Remover...")
+    rembg = BackgroundRemover()
+    
+    # ==================== Gather Input Images & Set Up Folders ====================
+    # Build absolute path for the input folder
+    input_folder = os.path.join("/scratch/cvlab/home/seiler/physiopt_new/input", args.input)
+    
+    # Check if the absolute path is a valid existing directory
+    if os.path.isdir(input_folder):
+        logging.info(f"📁 Input is a directory. Searching for images in: {input_folder}")
+        # Build image paths
+        image_paths = sorted([
+            os.path.join(input_folder, f) for f in os.listdir(input_folder)
+            if f.lower().endswith(('.png', '.jpg', '.jpeg', '.webp'))
+        ])
+        
+        # Base output folder takes the name of the input argument
+        base_out_folder = os.path.join("/scratch/cvlab/home/seiler/physiopt_new/output/hunyuan_gen", args.input)
+    else:
+        logging.error(f"❌ Error: Input path must be a valid folder. Could not find: {input_folder}")
+        sys.exit(1)
+
+    if not image_paths:
+        logging.error(f"❌ No images found in {input_folder}")
+        sys.exit(1)
+
+    logging.info(f"✅ Found {len(image_paths)} image(s) to process.")
+    
+    # Create the root output directory
+    os.makedirs(base_out_folder, exist_ok=True)
+    
+    # ==================== Main Loop over Images ====================
+    for img_path in image_paths:
+        img_name = os.path.splitext(os.path.basename(img_path))[0]
+        current_out_folder = os.path.join(base_out_folder, img_name)
+        
+        # Skip if output already exists
+        check_file = os.path.join(current_out_folder, "latents.pt")
+        if os.path.exists(check_file):
+            logging.info(f"⏭️  Skipping: Output already exists for {img_name} ({check_file})")
+            continue
+
+        os.makedirs(current_out_folder, exist_ok=True)
+        
+        logging.info("="*60)
+        logging.info(f"📷 Processing image: {img_path}")
+        logging.info(f"📁 Output will be saved to: {current_out_folder}")
+        
+        # Load and process image
+        image = Image.open(img_path).convert("RGBA")
+        
+        if image.mode == 'RGB':
+            logging.info("   Removing background...")
+            image = rembg(image)
+        
+        # Save the processed image
+        image.save(os.path.join(current_out_folder, "input_image.png"))
+        
+        # ==================== Generate the 3D shape ====================
+        logging.info("🎨 Generating 3D shape(s)...")
+        num_results = max(1, int(args.num_results))
+        
+        for idx in range(num_results):
+            sample_seed = args.seed + idx
+            # Handle subfolders for multiple results
+            if num_results == 1:
+                sample_out = current_out_folder
+            else:
+                sample_out = os.path.join(current_out_folder, f"sample_{idx:02d}")
+                os.makedirs(sample_out, exist_ok=True)
+                image.save(os.path.join(sample_out, "input_image.png"))
+            
+            logging.info(f"   === Sample {idx+1}/{num_results} | seed={sample_seed} ===")
+            torch.manual_seed(sample_seed)
+            np.random.seed(sample_seed)
+        
+            # Step 1: generate and save latents
+            latents = pipeline(
+                image=image,
+                num_inference_steps=args.num_inference_steps,
+                guidance_scale=args.guidance_scale,
+                generator=torch.Generator(device='cuda').manual_seed(sample_seed),
+                output_type='latent',
+            )
+            
+            # Save latents
+            latents_path = os.path.join(sample_out, "latents.pt")
+            save_dict = {
+                'latents': latents.cpu() if isinstance(latents, torch.Tensor) else latents,
+                'image': np.array(image)
+            }
+            torch.save(save_dict, latents_path)
+            logging.info(f"   ✅ Saved latents to: {latents_path}")
+            
+            # Step 2: decode latents to a mesh
+            logging.info("   🎭 Decoding latents into a mesh...")
+            mesh = pipeline._export(
+                latents,
+                output_type='trimesh',
+                box_v=1.01,
+                mc_level=args.mc_level,
+                num_chunks=20000,
+                octree_resolution=args.octree_resolution,
+                mc_algo='mc',
+                enable_pbar=False # Avoid progress bar spam
+            )[0]
+            
+            # Save the mesh
+            mesh.export(os.path.join(sample_out, "generated_mesh.obj"))
+            mesh.export(os.path.join(sample_out, "generated_mesh.glb"))
+            logging.info("   💾 Saved OBJ and GLB meshes")
+            
+            # Free memory
+            del mesh
+            del latents
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+
+    logging.info("="*60)
+    logging.info(f"✅ All {len(image_paths)} images processed successfully!")
+    logging.info(f"📂 Check the outputs in: {base_out_folder}")