Changeset 425

Timestamp:

02/23/2009 07:31:57 PM (3 years ago)

Author:

powell

Message:

Whitespace fix, to distinguish from prior substantive fix.

Files:

• trunk/matml/src/ternary/qhull.c (modified) (2 diffs)

trunk/matml/src/ternary/qhull.c

@@ -439 +439 @@
         }
 
-          int eparamc=0;
-
-#ifdef DEBUG
-          printf ("Facet %d: %g,%g %g,%g %g,%g\n", i,
-                  corners[0], corners[1], corners[3],
-                  corners[4], corners[6], corners[7]);
-          printf ("  Curves: %d %d %d, points %d %d %d, Area: %g\n",
-                  eparam[0], eparam[1], eparam[2],
-                  thepoint[0], thepoint[1], thepoint[2],
-                  fabs((corners[3]-corners[0])*(corners[7]-corners[1]) -
-                  (corners[6]-corners[0])*(corners[4]-corners[1])));
-#endif
-
+#ifdef DEBUG
+      printf ("Facet %d: %g,%g %g,%g %g,%g\n", i,
+              corners[0], corners[1], corners[3],
+              corners[4], corners[6], corners[7]);
+      printf ("  Curves: %d %d %d, points %d %d %d, Area: %g\n",
+              eparam[0], eparam[1], eparam[2],
+              thepoint[0], thepoint[1], thepoint[2],
+              fabs((corners[3]-corners[0])*(corners[7]-corners[1]) -
+                   (corners[6]-corners[0])*(corners[4]-corners[1])));
+#endif
+
+      /*+
+        +latex+\item
+        +html+ <li>
+        If this is a one-phase facet, optionally add the centroid as a new
+        vertex.
+        +html+ </li>
+        +*/
+      centroid[0] = (corners[0] + corners[3] + corners[6]) / 3.;
+      centroid[1] = (corners[1] + corners[4] + corners[7]) / 3.;
+      centroid[2] = (corners[2] + corners[5] + corners[8]) / 3.;
+
+      if ((*facets) [i].type == ONE_PHASE && one_phase_refine)
+        {
+#ifdef DEBUG
+          printf ("  Refining one-phase triangle at centroid\n");
+#endif
+          if (numnewpoints >= newpointsize)
+            newpoints = realloc
+              (newpoints, (newpointsize+=100)*sizeof(ternary_point));
+          newpoints [numnewpoints].C2 = centroid[0];
+          newpoints [numnewpoints].C3 = centroid[1];
+          newpoints [numnewpoints].G  = free_energy
+            (centroid[0], centroid[1], T, P, eparams+eparam [0]);
+          newpoints [numnewpoints].efunc = eparam [0];
+          numnewpoints++;
+        }
+
+      /*+
+        +latex+\item
+        +html+ <li>
+        Otherwise, use Newton-Raphson iteration to refine each vertex,
+        which consists of the remaining steps.
+        +html+ </li>
+        +*/
+      else if ((*facets) [i].type != ONE_PHASE)
+        {
+          coordT newcorners [9] = { corners[0], corners[1], corners[2],
+                                    corners[3], corners[4], corners[5],
+                                    corners[6], corners[7], corners[8]};
+
+#ifdef DEBUG
+          printf ("  Refining multi-phase triangle\n");
+#endif
           /*+
             +latex+\item
             +html+ <li>
-            If this is a one-phase facet, optionally add the centroid as a new
-            vertex.
+            If the vertex is on a side of the phase diagram (one or more
+            composition variables is zero or they sum to one), refine generally
+            starting a bit closer to the others.
             +html+ </li>
             +*/
-          centroid[0] = (corners[0] + corners[3] + corners[6]) / 3.;
-          centroid[1] = (corners[1] + corners[4] + corners[7]) / 3.;
-          centroid[2] = (corners[2] + corners[5] + corners[8]) / 3.;
-
-          if ((*facets) [i].type == ONE_PHASE && one_phase_refine)
+          for (j=0; j<3; j++)
             {
-#ifdef DEBUG
-                  printf ("  Refining one-phase triangle at centroid\n");
-#endif
-                  if (numnewpoints >= newpointsize)
-                    newpoints = realloc
-                      (newpoints, (newpointsize+=100)*sizeof(ternary_point));
-                  newpoints [numnewpoints].C2 = centroid[0];
-                  newpoints [numnewpoints].C3 = centroid[1];
-                  newpoints [numnewpoints].G  = free_energy
-                    (centroid[0], centroid[1], T, P, eparams+eparam [0]);
-                  newpoints [numnewpoints].efunc = eparam [0];
-                  numnewpoints++;
+              if (corners[3*j] == 0. || corners[3*j+1] == 0 ||
+                  corners[3*j] + corners[3*j+1] == 1.)
+                {
+                  newcorners[3*j] =
+                    0.9999999998 * corners[3*j] +
+                    0.0000000001 * corners[3*((j+1)%3)] +
+                    0.0000000001 * corners[3*((j+2)%3)];
+                  newcorners[3*j+1] =
+                    0.9999999998 * corners[3*j+1] +
+                    0.0000000001 * corners[3*((j+1)%3)+1] +
+                    0.0000000001 * corners[3*((j+2)%3)+1];
+                  newcorners[3*j+2] =
+                    0.9999999998 * corners[3*j+2] +
+                    0.0000000001 * corners[3*((j+1)%3)+2] +
+                    0.0000000001 * corners[3*((j+2)%3)+2];
+                }
             }
 
@@ -482 +524 @@
             +latex+\item
             +html+ <li>
-            Otherwise, use Newton-Raphson iteration to refine each vertex,
-            which consists of the remaining steps.
+            Refine the vertices of the facet using
+            +latex+{\tt NewtonRefine()} (section
+            +latex+\ref{func_NewtonRefine_qhull.c} page
+            +latex+\pageref{func_NewtonRefine_qhull.c}).
+            +html+ <a href="#func-NewtonRefine"><tt>NewtonRefine()</tt></a>.</li>
+            +*/
+          for (j=0; j<3; j++)
+            {
+#ifdef DEBUG
+              printf ("    Refining point at %g, %g function %d\n",
+                      newcorners[3*j], newcorners[3*j+1], eparam[j]);
+#endif
+              NewtonRefine (newcorners+3*j, corners, eparams+eparam[j],
+                            T,P, 3,3, newton_tolerance);
+#ifdef DEBUG
+              printf ("    -> %g, %g\n", newcorners[3*j],
+                      newcorners[3*j+1]);
+#endif
+
+              newcorners[3*j+2] = free_energy
+                (newcorners[3*j],newcorners[3*j+1], T,P, eparams+eparam[j]);
+            }
+
+          /*+
+            +latex+\item
+            +html+ <li>
+            Add new points, leaving out duplicates in same place (closer
+            than vertex_tolerance).
             +html+ </li>
             +*/
-          else if ((*facets) [i].type != ONE_PHASE)
+
+          // Don't add the point, reallocate the points array instead!
+          if (newcorners[0]>=0. && newcorners[1]>=0. &&
+              newcorners[0]+newcorners[1]<=1.)
             {
-              coordT newcorners [9] = { corners[0], corners[1], corners[2],
-                                        corners[3], corners[4], corners[5],
-                                        corners[6], corners[7], corners[8]};
-
-#ifdef DEBUG
-              printf ("  Refining multi-phase triangle\n");
-#endif
-              for (j=0; j<3; j++)
-                {
-                  /*+
-                    +latex+\item
-                    +html+ <li>
-                    If the vertex is on a side of the phase diagram (one or
-                    more composition variables is zero or they sum to one),
-                    refine generally starting a bit closer to the others.
-                    +html+ </li>
-                    +*/
-                  if (corners[3*j] == 0. || corners[3*j+1] == 0 ||
-                      corners[3*j] + corners[3*j+1] == 1.)
-                    {
-                      newcorners[3*j] =
-                        0.9999999998 * corners[3*j] +
-                        0.0000000001 * corners[3*((j+1)%3)] +
-                        0.0000000001 * corners[3*((j+2)%3)];
-                      newcorners[3*j+1] =
-                        0.9999999998 * corners[3*j+1] +
-                        0.0000000001 * corners[3*((j+1)%3)+1] +
-                        0.0000000001 * corners[3*((j+2)%3)+1];
-                      newcorners[3*j+2] =
-                        0.9999999998 * corners[3*j+2] +
-                        0.0000000001 * corners[3*((j+1)%3)+2] +
-                        0.0000000001 * corners[3*((j+2)%3)+2];
-                    }
-                }
-
-              /*+
-                +latex+\item
-                +html+ <li>
-                Refine the vertices of the facet using
-                +latex+{\tt NewtonRefine()} (section
-                +latex+\ref{func_NewtonRefine_qhull.c} page
-                +latex+\pageref{func_NewtonRefine_qhull.c}).
-                +html+ <a href="#func-NewtonRefine"><tt>NewtonRefine()</tt></a>.</li>
-                +*/
-              for (j=0; j<3; j++)
-                {
-#ifdef DEBUG
-                  printf ("    Refining point at %g, %g function %d\n",
-                          newcorners[3*j], newcorners[3*j+1], eparam[j]);
-#endif
-                  NewtonRefine (newcorners+3*j, corners, eparams+eparam[j],
-                                T,P, 3,3, newton_tolerance);
-#ifdef DEBUG
-                  printf ("    -> %g, %g\n", newcorners[3*j],
-                          newcorners[3*j+1]);
-#endif
-
-                  newcorners[3*j+2] = free_energy
-                    (newcorners[3*j],newcorners[3*j+1], T,P, eparams+eparam[j]);
-                }
-
-              /*+
-                +latex+\item
-                +html+ <li>
-                Add new points, leaving out duplicates in same place (closer
-                than vertex_tolerance).
-                +html+ </li>
-                +*/
-
-              // Don't add the point, reallocate the points array instead!
-              if (newcorners[0]>=0. && newcorners[1]>=0. &&
-                  newcorners[0]+newcorners[1]<=1.)
-                {
-#ifdef DEBUG
-                  printf ("    Adding new point %g,%g,%g\n",
-                    newcorners[0], newcorners[1], newcorners[2]);
-#endif
-                  if (numnewpoints >= newpointsize)
-                    newpoints = realloc
-                      (newpoints, (newpointsize+=100)*sizeof(ternary_point));
-                  newpoints [numnewpoints].C2 = newcorners[0];
-                  newpoints [numnewpoints].C3 = newcorners[1];
-                  newpoints [numnewpoints].G  = newcorners[2];
-                  newpoints [numnewpoints].efunc = eparam[0];
-                  numnewpoints++;
-                }
-
-              if ((newcorners[3]-newcorners[0])*(newcorners[3]-newcorners[0]) +
-                  (newcorners[4]-newcorners[1])*(newcorners[4]-newcorners[1]) +
-                  (newcorners[5]-newcorners[2])*(newcorners[5]-newcorners[2]) >
-                  vertex_tolerance * vertex_tolerance &&
-                  newcorners[3]>=0. && newcorners[4]>=0. &&
-                  newcorners[3]+newcorners[4]<=1.)
-                {
-#ifdef DEBUG
-                  printf ("    Adding new point %g,%g,%g\n",
-                          newcorners[3], newcorners[4], newcorners[5]);
-#endif
-                  if (numnewpoints >= newpointsize)
-                    newpoints = realloc
-                      (newpoints, (newpointsize+=100)*sizeof(ternary_point));
-                  newpoints [numnewpoints].C2 = newcorners[3];
-                  newpoints [numnewpoints].C3 = newcorners[4];
-                  newpoints [numnewpoints].G  = newcorners[5];
-                  newpoints [numnewpoints].efunc = eparam[1];
-                  numnewpoints++;
-                }
-
-              if ((newcorners[6]-newcorners[0])*(newcorners[6]-newcorners[0]) +
-                  (newcorners[7]-newcorners[1])*(newcorners[7]-newcorners[1]) +
-                  (newcorners[8]-newcorners[2])*(newcorners[8]-newcorners[2]) >
-                  vertex_tolerance * vertex_tolerance &&
-                  (newcorners[6]-newcorners[3])*(newcorners[6]-newcorners[3]) +
-                  (newcorners[7]-newcorners[4])*(newcorners[7]-newcorners[4]) +
-                  (newcorners[8]-newcorners[5])*(newcorners[8]-newcorners[5]) >
-                  vertex_tolerance * vertex_tolerance &&
-                  newcorners[6]>=0. && newcorners[7]>=0. &&
-                  newcorners[6]+newcorners[7]<=1.)
-                {
-#ifdef DEBUG
-                  printf ("    Adding new point %g,%g,%g\n",
-                          newcorners[6], newcorners[7], newcorners[8]);
-#endif
-                  if (numnewpoints >= newpointsize)
-                    newpoints = realloc
-                      (newpoints, (newpointsize+=100)*sizeof(ternary_point));
-                  newpoints [numnewpoints].C2 = newcorners[6];
-                  newpoints [numnewpoints].C3 = newcorners[7];
-                  newpoints [numnewpoints].G  = newcorners[8];
-                  newpoints [numnewpoints].efunc = eparam[1];
-                  numnewpoints++;
-                }
+#ifdef DEBUG
+              printf ("    Adding new point %g,%g,%g\n",
+                      newcorners[0], newcorners[1], newcorners[2]);
+#endif
+              if (numnewpoints >= newpointsize)
+                newpoints = realloc
+                  (newpoints, (newpointsize+=100)*sizeof(ternary_point));
+              newpoints [numnewpoints].C2 = newcorners[0];
+              newpoints [numnewpoints].C3 = newcorners[1];
+              newpoints [numnewpoints].G  = newcorners[2];
+              newpoints [numnewpoints].efunc = eparam[0];
+              numnewpoints++;
             }
+
+          if ((newcorners[3]-newcorners[0])*(newcorners[3]-newcorners[0]) +
+              (newcorners[4]-newcorners[1])*(newcorners[4]-newcorners[1]) +
+              (newcorners[5]-newcorners[2])*(newcorners[5]-newcorners[2]) >
+              vertex_tolerance * vertex_tolerance &&
+              newcorners[3]>=0. && newcorners[4]>=0. &&
+              newcorners[3]+newcorners[4]<=1.)
+            {
+#ifdef DEBUG
+              printf ("    Adding new point %g,%g,%g\n",
+                      newcorners[3], newcorners[4], newcorners[5]);
+#endif
+              if (numnewpoints >= newpointsize)
+                newpoints = realloc
+                  (newpoints, (newpointsize+=100)*sizeof(ternary_point));
+              newpoints [numnewpoints].C2 = newcorners[3];
+              newpoints [numnewpoints].C3 = newcorners[4];
+              newpoints [numnewpoints].G  = newcorners[5];
+              newpoints [numnewpoints].efunc = eparam[1];
+              numnewpoints++;
+            }
+
+          if ((newcorners[6]-newcorners[0])*(newcorners[6]-newcorners[0]) +
+              (newcorners[7]-newcorners[1])*(newcorners[7]-newcorners[1]) +
+              (newcorners[8]-newcorners[2])*(newcorners[8]-newcorners[2]) >
+              vertex_tolerance * vertex_tolerance &&
+              (newcorners[6]-newcorners[3])*(newcorners[6]-newcorners[3]) +
+              (newcorners[7]-newcorners[4])*(newcorners[7]-newcorners[4]) +
+              (newcorners[8]-newcorners[5])*(newcorners[8]-newcorners[5]) >
+              vertex_tolerance * vertex_tolerance &&
+              newcorners[6]>=0. && newcorners[7]>=0. &&
+              newcorners[6]+newcorners[7]<=1.)
+            {
+#ifdef DEBUG
+              printf ("    Adding new point %g,%g,%g\n",
+                      newcorners[6], newcorners[7], newcorners[8]);
+#endif
+              if (numnewpoints >= newpointsize)
+                newpoints = realloc
+                  (newpoints, (newpointsize+=100)*sizeof(ternary_point));
+              newpoints [numnewpoints].C2 = newcorners[6];
+              newpoints [numnewpoints].C3 = newcorners[7];
+              newpoints [numnewpoints].G  = newcorners[8];
+              newpoints [numnewpoints].efunc = eparam[1];
+              numnewpoints++;
+            }
+        }
     }
   /*+