A Simple Cluster Generator v0.1
Overview:

Instantiating a random engine is relatively expensive. Also creating one each loop does not increase your entropy (more likely decreases but I am not a mathamtician so don't homd me to that). BUT it is fine to create it once:

// Do this once at the beginning of the function
std::default_random_engine gen(std::chrono::system_clock::now().time_since_epoch().count());


Modern C++ techniques:

// C++ 03
for (std::vector&lt;std::vector&lt;double&gt;&gt;::iterator c_iter = c.begin(); c_iter != c.end(); ++c_iter)


In C++ 11 we can let the compiler determine the type:

// C++ 11
for (auto c_iter = c.begin(); c_iter != c.end(); ++c_iter)


In C++14 they introduced range based for()

// C++ 14
for (auto&amp; cValue : c) //  Note:: cValue =&gt; *c_iter from the above examples.


Looking at the inner loop:

    std::vector&lt;double&gt;::iterator d_iter = (*c_iter).begin();
    while (d_iter != (*c_iter).end()) {
        // STUFF
        ++d_iter;
    }


We replace this while loop with a for loop.

   for (auto d_iter = (*c_iter).begin(); d_iter != (*c_iter).end(); ++d_iter)


Which of course we can then apply all the above transformations on and get the same result:

   for (auto dValue: *c_iter)


We should also note that -&gt; is short hand for (*).

   // eg:
   (*c_iter).begin()

   // written more succinctly as:
   c_iter-&gt;begin()


Over Complex

(k % c.size() == 0) ? (subsec = (k + ct) / c.size()) : (subsec = 1 + ((k + ct) / c.size()));


First of that is hard to read. Spread it out:

(k % c.size() == 0)
    ? (subsec = (k + ct) / c.size())
    : (subsec = 1 + ((k + ct) / c.size()));


Second this relies on sideeffects of the expression. This is usually not a good idea. Let expressions by simple (with no side affects). Use the result of the whole thing to do the assignment:

subsec = (k % c.size() == 0)
    ? ((k + ct) / c.size())
    : (1 + ((k + ct) / c.size()));


// Also this:
rout &lt;&lt; (norm) ? "normally" : "uniformly";  // from your monstrocity.


I also think I see a common sub expression in there. Extract that and assign it to a meaningful variable name to help document your code:

auto someMeaningfulName = (k + ct) / c.size();
subsec = (k % c.size() == 0)
    ? someMeaningfulName
    : 1 + someMeaningfulName;


OK. Now I can make this even more readable:

auto someMeaningfulName = (k + ct) / c.size();
subsec = someMeaningfulName + ((k % c.size() == 0) ? 0 : 1);


One line per declaration

std::ofstream fout, rout;
fout.open(file_out);
rout.open(file_rpt);


Use one line to declare each variable (and put some more meaningful names on them). Also there is no reason to explicitly call the open() method as this is handeled by the constructor:

std::ofstream fout(file_out);
std::ofstream rout(file_rpt);