diff --git a/internal/ceres/iterative_schur_complement_solver.cc b/internal/ceres/iterative_schur_complement_solver.cc
index cf5562a..15e0bdc 100644
--- a/internal/ceres/iterative_schur_complement_solver.cc
+++ b/internal/ceres/iterative_schur_complement_solver.cc
@@ -99,7 +99,6 @@
   preconditioner_options.type = options_.preconditioner_type;
   preconditioner_options.sparse_linear_algebra_library =
       options_.sparse_linear_algebra_library;
-  preconditioner_options.use_block_amd = options_.use_block_amd;
   preconditioner_options.num_threads = options_.num_threads;
   preconditioner_options.row_block_size = options_.row_block_size;
   preconditioner_options.e_block_size = options_.e_block_size;
diff --git a/internal/ceres/linear_solver.h b/internal/ceres/linear_solver.h
index f4bd0fb..ca10faa 100644
--- a/internal/ceres/linear_solver.h
+++ b/internal/ceres/linear_solver.h
@@ -74,7 +74,7 @@
         : type(SPARSE_NORMAL_CHOLESKY),
           preconditioner_type(JACOBI),
           sparse_linear_algebra_library(SUITE_SPARSE),
-          use_block_amd(true),
+          use_postordering(false),
           min_num_iterations(1),
           max_num_iterations(1),
           num_threads(1),
@@ -90,8 +90,8 @@
 
     SparseLinearAlgebraLibraryType sparse_linear_algebra_library;
 
-    // See solver.h for explanation of this option.
-    bool use_block_amd;
+    // See solver.h for information about this flag.
+    bool use_postordering;
 
     // Number of internal iterations that the solver uses. This
     // parameter only makes sense for iterative solvers like CG.
diff --git a/internal/ceres/preconditioner.h b/internal/ceres/preconditioner.h
index bfc8464..d7c8829 100644
--- a/internal/ceres/preconditioner.h
+++ b/internal/ceres/preconditioner.h
@@ -47,7 +47,6 @@
     Options()
         : type(JACOBI),
           sparse_linear_algebra_library(SUITE_SPARSE),
-          use_block_amd(true),
           num_threads(1),
           row_block_size(Eigen::Dynamic),
           e_block_size(Eigen::Dynamic),
@@ -58,9 +57,6 @@
 
     SparseLinearAlgebraLibraryType sparse_linear_algebra_library;
 
-    // See solver.h for explanation of this option.
-    bool use_block_amd;
-
     // If possible, how many threads the preconditioner can use.
     int num_threads;
 
diff --git a/internal/ceres/schur_complement_solver.cc b/internal/ceres/schur_complement_solver.cc
index 875f455..8afb121 100644
--- a/internal/ceres/schur_complement_solver.cc
+++ b/internal/ceres/schur_complement_solver.cc
@@ -286,11 +286,7 @@
 
   // Symbolic factorization is computed if we don't already have one handy.
   if (factor_ == NULL) {
-    if (options().use_block_amd) {
-      factor_ = ss_.BlockAnalyzeCholesky(cholmod_lhs, blocks_, blocks_);
-    } else {
-      factor_ = ss_.AnalyzeCholesky(cholmod_lhs);
-    }
+    factor_ = ss_.BlockAnalyzeCholesky(cholmod_lhs, blocks_, blocks_);
   }
 
   cholmod_dense* cholmod_solution =
diff --git a/internal/ceres/solver_impl.cc b/internal/ceres/solver_impl.cc
index 0d7b83c..8217484 100644
--- a/internal/ceres/solver_impl.cc
+++ b/internal/ceres/solver_impl.cc
@@ -1004,7 +1004,8 @@
     return transformed_program.release();
   }
 
-  if (options->linear_solver_type == SPARSE_NORMAL_CHOLESKY) {
+  if (options->linear_solver_type == SPARSE_NORMAL_CHOLESKY &&
+      options->sparse_linear_algebra_library == SUITE_SPARSE) {
     ReorderProgramForSparseNormalCholesky(transformed_program.get());
     return transformed_program.release();
   }
@@ -1091,11 +1092,10 @@
   linear_solver_options.preconditioner_type = options->preconditioner_type;
   linear_solver_options.sparse_linear_algebra_library =
       options->sparse_linear_algebra_library;
-
+  linear_solver_options.use_postordering = options->use_postordering;
   linear_solver_options.num_threads = options->num_linear_solver_threads;
   options->num_linear_solver_threads = linear_solver_options.num_threads;
 
-  linear_solver_options.use_block_amd = options->use_block_amd;
   const map<int, set<double*> >& groups =
       options->linear_solver_ordering->group_to_elements();
   for (map<int, set<double*> >::const_iterator it = groups.begin();
diff --git a/internal/ceres/sparse_normal_cholesky_solver.cc b/internal/ceres/sparse_normal_cholesky_solver.cc
index 0cd064b..bc1f983 100644
--- a/internal/ceres/sparse_normal_cholesky_solver.cc
+++ b/internal/ceres/sparse_normal_cholesky_solver.cc
@@ -204,14 +204,15 @@
   event_logger.AddEvent("Setup");
 
   if (factor_ == NULL) {
-    if (options_.use_block_amd) {
+    if (options_.use_postordering) {
       factor_ = ss_.BlockAnalyzeCholesky(&lhs,
                                          A->col_blocks(),
                                          A->row_blocks());
     } else {
-      factor_ = ss_.AnalyzeCholesky(&lhs);
+      factor_ = ss_.AnalyzeCholeskyWithNaturalOrdering(&lhs);
     }
   }
+
   event_logger.AddEvent("Analysis");
 
   cholmod_dense* sol = ss_.SolveCholesky(&lhs, factor_, rhs);
diff --git a/internal/ceres/unsymmetric_linear_solver_test.cc b/internal/ceres/unsymmetric_linear_solver_test.cc
index 0b0d593..c8a15c0 100644
--- a/internal/ceres/unsymmetric_linear_solver_test.cc
+++ b/internal/ceres/unsymmetric_linear_solver_test.cc
@@ -62,7 +62,6 @@
     LinearSolver::Options options;
     options.type = linear_solver_type;
     options.sparse_linear_algebra_library = sparse_linear_algebra_library;
-    options.use_block_amd = false;
     scoped_ptr<LinearSolver> solver(LinearSolver::Create(options));
 
     LinearSolver::PerSolveOptions per_solve_options;
diff --git a/internal/ceres/visibility_based_preconditioner.cc b/internal/ceres/visibility_based_preconditioner.cc
index f5c46bf..4b1e26a 100644
--- a/internal/ceres/visibility_based_preconditioner.cc
+++ b/internal/ceres/visibility_based_preconditioner.cc
@@ -421,11 +421,7 @@
 
   // Symbolic factorization is computed if we don't already have one handy.
   if (factor_ == NULL) {
-    if (options_.use_block_amd) {
-      factor_ = ss_.BlockAnalyzeCholesky(lhs, block_size_, block_size_);
-    } else {
-      factor_ = ss_.AnalyzeCholesky(lhs);
-    }
+    factor_ = ss_.BlockAnalyzeCholesky(lhs, block_size_, block_size_);
   }
 
   bool status = ss_.Cholesky(lhs, factor_);