Commit: 8326a9ac7cdf199450609535a91304459cb155b3
Author: mattoverby
Date:   Tue Aug 11 19:30:05 2020 -0500
Branches: soc-2020-soft-body
https://developer.blender.org/rB8326a9ac7cdf199450609535a91304459cb155b3

updated how stiffnesses are shown in gui

===================================================================

M       extern/softbody/src/admmpd_collision.cpp
M       extern/softbody/src/admmpd_linsolve.cpp
M       extern/softbody/src/admmpd_mesh.cpp
M       extern/softbody/src/admmpd_solver.cpp
M       extern/softbody/src/admmpd_types.h
M       intern/softbody/admmpd_api.cpp
M       release/scripts/startup/bl_ui/properties_physics_softbody.py
M       source/blender/blenkernel/intern/softbody.c
M       source/blender/makesdna/DNA_object_force_types.h
M       source/blender/makesrna/intern/rna_object_force.c

===================================================================

diff --git a/extern/softbody/src/admmpd_collision.cpp 
b/extern/softbody/src/admmpd_collision.cpp
index 0ef217b0c99..c9609c1da03 100644
--- a/extern/softbody/src/admmpd_collision.cpp
+++ b/extern/softbody/src/admmpd_collision.cpp
@@ -93,6 +93,7 @@ Collision::detect_against_obs(
        (void)(mesh);
        (void)(options);
        (void)(data);
+       (void)(pt_t0);
 
        std::pair<bool,VFCollisionPair> ret = 
                std::make_pair(false, VFCollisionPair());
@@ -320,6 +321,9 @@ void EmbeddedMeshCollision::update_bvh(
        const Eigen::MatrixXd *x1,
        bool sort)
 {
+       (void)(options);
+       (void)(x0);
+
        if (!mesh)
                return;
 
@@ -360,7 +364,11 @@ EmbeddedMeshCollision::detect_against_self(
        const Eigen::MatrixXd *x0,
        const Eigen::MatrixXd *x1) const
 {
-       (void)(pt_t0); (void)(x0);
+       (void)(pt_t0);
+       (void)(x0);
+       (void)(options);
+       (void)(data);
+
        std::pair<bool,VFCollisionPair> ret = 
                std::make_pair(false, VFCollisionPair());
 
@@ -516,6 +524,7 @@ void EmbeddedMeshCollision::linearize(
        std::vector<Eigen::Triplet<double> > *trips,
        std::vector<double> *d) const
 {
+       (void)(data);
        BLI_assert(x != NULL);
        BLI_assert(x->cols() == 3);
 
diff --git a/extern/softbody/src/admmpd_linsolve.cpp 
b/extern/softbody/src/admmpd_linsolve.cpp
index 87e10cc357b..bd06f5910a7 100644
--- a/extern/softbody/src/admmpd_linsolve.cpp
+++ b/extern/softbody/src/admmpd_linsolve.cpp
@@ -42,12 +42,11 @@ void LDLT::init_solve(
 
        // If we've changed the stiffness but not the pins,
        // the P matrix is still changing
-       double pk = options->mult_pk * data->A_diag_max;
-       if (std::abs(pk-data->ls.last_pk) > 1e-8 && trips.size()>0)
+       if (std::abs(options->pk-data->ls.last_pk) > 1e-8 && trips.size()>0)
                new_P = true;
 
        // Compute P
-       data->ls.last_pk = pk;
+       data->ls.last_pk = options->pk;
        int np = q_coeffs.size()/3;
        SparseMatrix<double> P;
        MatrixXd q;
@@ -72,14 +71,12 @@ void LDLT::init_solve(
                        q(i,1) = q_coeffs[i*3+1];
                        q(i,2) = q_coeffs[i*3+2];
                }
-               data->ls.Ptq = pk * P.transpose() * q;
+               data->ls.Ptq = options->pk * P.transpose() * q;
        }
 
        if (!data->ls.ldlt_A_PtP)
                data->ls.ldlt_A_PtP = std::make_unique<Cholesky>();
 
-std::cout << "factoring" << std::endl;
-
        // Compute A + P'P and factorize:
        // 1) A not computed
        // 2) P has changed
@@ -88,7 +85,7 @@ std::cout << "factoring" << std::endl;
                data->ls.A_PtP.nonZeros()==0 ||
                new_P)
        {
-               data->ls.A_PtP = SparseMatrix<double>(data->A) + pk * 
P.transpose()*P;
+               data->ls.A_PtP = SparseMatrix<double>(data->A) + options->pk * 
P.transpose()*P;
                data->ls.ldlt_A_PtP->compute(data->ls.A_PtP);
                if(data->ls.ldlt_A_PtP->info() != Eigen::Success)
                        throw_err("init_solve","facorization failed");
@@ -149,9 +146,8 @@ void LDLT::solve(
 
        // Otherwise we have to solve the full system:
        // (A + PtP + CtC) x = b + Ptq + Ctd
-       double ck = options->mult_ck * data->A_diag_max;
-       data->ls.A_PtP_CtC_3 = data->ls.A_PtP_3 + ck * C.transpose()*C;
-       VectorXd Ctd3 = ck * C.transpose() * d;
+       data->ls.A_PtP_CtC_3 = data->ls.A_PtP_3 + options->ck * C.transpose()*C;
+       VectorXd Ctd3 = options->ck * C.transpose() * d;
        VectorXd rhs3(nx*3);
        for (int i=0; i<nx; ++i)
        {
@@ -240,8 +236,8 @@ void ConjugateGradients::solve(
        };
 
        // Linearize collision constraints
-       RowSparseMatrix<double> C;
-       VectorXd d;
+       RowSparseMatrix<double> C(1,nx*3);
+       VectorXd d = VectorXd::Zero(1);
        if (collision != nullptr)
        {
                std::vector<double> d_coeffs;
@@ -255,11 +251,6 @@ void ConjugateGradients::solve(
                        C.setFromTriplets(trips.begin(),trips.end());           
                }
        }
-       else
-       {
-               C.resize(1,nx*3);
-               d = VectorXd::Zero(1);
-       }
 
        // Compute RHS
        data->ls.rhs.noalias() =
@@ -277,9 +268,8 @@ void ConjugateGradients::solve(
 
        // Otherwise we have to replicate the system
        // (A + PtP + CtC) x = Mxbar + DtW2(z-u) + Ptq
-       double ck = options->mult_ck * data->A_diag_max;
-       data->ls.A_PtP_CtC_3 = data->ls.A_PtP_3 + ck * C.transpose()*C;
-       map_vector_to_matrix(ck*C.transpose()*d, data->ls.Ctd);
+       data->ls.A_PtP_CtC_3 = data->ls.A_PtP_3 + options->ck * C.transpose()*C;
+       map_vector_to_matrix(options->ck*C.transpose()*d, data->ls.Ctd);
        data->ls.rhs.noalias() += data->ls.Ctd;
 
        // Grab refs for convenience
diff --git a/extern/softbody/src/admmpd_mesh.cpp 
b/extern/softbody/src/admmpd_mesh.cpp
index 52d8e2d0cda..d130b6345b0 100644
--- a/extern/softbody/src/admmpd_mesh.cpp
+++ b/extern/softbody/src/admmpd_mesh.cpp
@@ -228,8 +228,8 @@ bool EmbeddedMesh::compute_embedding()
        {
                (void)(tls);
                FindTetThreadData *td = (FindTetThreadData*)userdata;
-               const MatrixXd *emb_V0 = td->emb_mesh->rest_facet_verts();
-               Vector3d pt = emb_V0->row(i);
+               const MatrixXd *emb_x0 = td->emb_mesh->rest_facet_verts();
+               Vector3d pt = emb_x0->row(i);
                PointInTetMeshTraverse<double> traverser(
                                pt,
                                td->lat_V0,
@@ -421,18 +421,26 @@ bool EmbeddedMesh::linearize_pins(
                        q.emplace_back(qi[i]*ki);
                }
 
+               double btb = 1;//bary.dot(bary);
+
                if (replicate)
                {
                        for (int i=0; i<3; ++i)
                        {
                                for (int j=0; j<4; ++j)
-                                       trips.emplace_back(p_idx*3+i, 
tet[j]*3+i, bary[j]*ki);
+                               {
+                                       double wi = bary[j]/btb;
+                                       trips.emplace_back(p_idx*3+i, 
tet[j]*3+i, wi*ki);
+                               }
                        }
                }
                else
                {
                        for (int j=0; j<4; ++j)
-                               trips.emplace_back(p_idx, tet[j], bary[j]*ki);  
+                       {
+                               double wi = bary[j]/btb;
+                               trips.emplace_back(p_idx, tet[j], wi*ki);
+                       }
                }
        }
 
diff --git a/extern/softbody/src/admmpd_solver.cpp 
b/extern/softbody/src/admmpd_solver.cpp
index dcc13489967..8a35da1e6b7 100644
--- a/extern/softbody/src/admmpd_solver.cpp
+++ b/extern/softbody/src/admmpd_solver.cpp
@@ -334,13 +334,9 @@ void Solver::init_matrices(
        data->D.setFromTriplets(trips.begin(), trips.end());
        data->DtW2 = data->D.transpose() * W2;
        data->A = data->DtW2 * data->D;
-       data->A_diag_max = 0;
        for (int i=0; i<nx; ++i)
        {
                data->A.coeffRef(i,i) += data->m[i]/dt2;
-               double Aii = data->A.coeff(i,i);
-               if (Aii > data->A_diag_max)
-                       data->A_diag_max = Aii;
        }
 
        // ADMM dual/lagrange
diff --git a/extern/softbody/src/admmpd_types.h 
b/extern/softbody/src/admmpd_types.h
index f06830c99f9..e3d5e796504 100644
--- a/extern/softbody/src/admmpd_types.h
+++ b/extern/softbody/src/admmpd_types.h
@@ -67,8 +67,8 @@ struct Options {
     int collision_mode;
     int substeps; // used externally, ignore in solve()
     double gs_omega; // Gauss-Seidel relaxation
-    double mult_ck; // stiffness multiplier for constraints
-    double mult_pk; // (global) stiffness multiplier for pins
+    double ck; // collision stiffness
+    double pk; // pin stiffness
     double min_res; // exit tolerance for global step
     double youngs; // Young's modulus // TODO variable per-tet
     double poisson; // Poisson ratio // TODO variable per-tet
@@ -89,8 +89,8 @@ struct Options {
         collision_mode(COLLISIONMODE_DISCRETE),
         substeps(1),
         gs_omega(1),
-        mult_ck(3),
-        mult_pk(3),
+        ck(10000),
+        pk(10000),
         min_res(1e-6),
         youngs(1000000),
         poisson(0.399),
@@ -117,7 +117,6 @@ public:
     RowSparseMatrix<double> DtW2; // D'W'W
     RowSparseMatrix<double> A; // M + DtW'WD
     RowSparseMatrix<double> W; // weight matrix
-    double A_diag_max; // Max coeff of diag of A
     // Set in append_energies:
     std::vector<std::set<int> > energies_graph; // per-vertex adjacency list 
(graph)
        std::vector<Eigen::Vector3i> indices; // per-energy index into D (row, 
num rows, type)
diff --git a/intern/softbody/admmpd_api.cpp b/intern/softbody/admmpd_api.cpp
index d4cae9b18fd..db9bfee8f9d 100644
--- a/intern/softbody/admmpd_api.cpp
+++ b/intern/softbody/admmpd_api.cpp
@@ -88,8 +88,8 @@ static inline void options_from_object(
   // Set options that don't require a re-initialization
   op->max_admm_iters = std::max(1,sb->admmpd_max_admm_iters);
   op->min_res = std::max(0.f,sb->admmpd_converge_eps);
-  op->mult_pk = std::max(0.f,std::min(1.f,sb->admmpd_goalstiff));
-  op->mult_ck = std::max(0.f,std::min(1.f,sb->admmpd_collisionstiff));
+  op->pk = std::pow(10.f, sb->admmpd_pk_exp);
+  op->ck = std::pow(10.f, sb->admmpd_ck_exp);
   op->floor = sb->admmpd_floor_z;
   op->self_collision = sb->admmpd_self_collision;
   op->log_level = std::max(0, std::min(LOGLEVEL_NUM-1, sb->admmpd_loglevel));
@@ -106,7 +106,7 @@ static inline void options_from_object(
       op->timestep_s = (1.0/fps) / float(std::max(1,sb->admmpd_substeps));
     }
     op->density_kgm3 = std::max(1.f,sb->admmpd_density_kgm3);
-    op->youngs = std::pow(10.f, std::max(0.f,sb->admmpd_youngs_exp));
+    op->youngs = std::pow(10.f, sb->admmpd_youngs_exp);
     op->poisson = std::max(0.f,std::min(0.499f,sb->admmpd_poisson));
     op->elastic_material = std::max(0, std::min(ELASTIC_NUM-1, 
sb->admmpd_material));
     op->substeps = std::max(1,sb->admmpd_substeps);
diff --git a/release/scripts/startup/bl_ui/properties_physics_softbody.py 
b/release/scripts/startup/bl_ui/properties_physics_softbody.py
index a39b0c4c7ce..a3d728dc2a5 100644
--- a/release/scripts/startup/bl_ui/properties_physics_softbody.py
+++ b/release/scripts/startup/bl_ui/properties_physics_softbody.py
@@ -159,7 +159,7 @@ class PHYSICS_PT_softbody_goal(PhysicButtonsPanel, Panel):
         layout.prop_search(softbody, "vertex_group_goal", ob, "vertex_groups", 
text="Vertex Group")
 
         if softbody.solver_mode == 'ADMMPD':
-            layout.prop(softbody, "admmpd_goalstiff")
+            layout.prop(softbody, "admmpd_pk_exp")
 
 
 class PHYSICS_PT_softbody_goal_strengths(PhysicButtonsPanel, Panel):
@@ -341,7 +341,7 @@ class 
PHYSICS_PT_softbody_admmpdcollision(PhysicButtonsPanel, Panel):
         softbody = md.settings
         layout.enabled = softbody_panel_enabled(md)
         layout.prop(softbody, "admmpd_self_collision")
-        layout.prop(softbody, "admmpd_collisionstiff")
+        layout.prop(softbody, "admmpd_ck_exp")
         layout.prop(softbody, "admmpd_floor_z")
 
 class PHYSICS_PT_softbody_collision(PhysicButtonsPanel, Panel):
diff --git a/source/blender/blenkernel/intern/softbody.c 
b/source/blender/blenkernel/intern/softbody.c
index 75fbea9c958..e742fc2ea1a 100644
--- a/source/blender/blenkernel/intern/softbody.c
+++ b/source/blender/blenkernel/intern/softbody.c
@@ -3134,8 +3134,8 @@

@@ Diff output truncated at 10240 characters. @@

_______________________________________________
Bf-blender-cvs mailing list
[email protected]
https://lists.blender.org/mailman/listinfo/bf-blender-cvs

Reply via email to