A Simple Cluster Generator v0.2

This code looks pretty good, but here are some things that may help you further improve it.

Separate interface from implementation

The interface goes into the .h file and the implementation goes into the .cpp file. Part of the interface is the required headers. What you have is not wrong, but I generally keep only the header files necesary for the interface in the .h file and anything that's not visible goes into the .cpp file. In this case, that means that <string> and <vector> would stay in the .h file and all other #includes go into the .cpp file. Also, if you put the include guard as the very first line of the file, the preprocessor may be sped up slightly because it doesn't have to scan the #include files.

Consider using an object

The PT_BOUND and PT_SD constants are described in the comments as user-defined variables and are required for clustergen(), but any user wanting to change them would have to touch the include file. Instead, I'd suggest using an object that contains the constants and defining a constructor that takes those two constants as parameters. This, for example:

class Cluster {
    double const PT_BOUND;
    double const PT_SD;

public:
    Cluster(double pt_bound = 10, double pt_sd = 5) :
        PT_BOUND{pt_bound}, 
        PT_SD{pt_sd}
    {}
    void gen(unsigned int k, std::vector<std::vector<double>> &c, std::string file_out, std::string file_rpt, bool csv, bool norm) const;
};

Split the function into smaller pieces

Right now, the function opens two files, cycles through the passed points generating each coordinate individually and writes both data and report. I'd suggest breaking those into individual functions. For example, I'd suggest creating a function to generate points around and individual point. Here's one way to write it (as an object member function):

std::vector<std::vector<double>> Cluster::around(const std::vector<double> &p, unsigned n) const {
    static std::default_random_engine gen{std::random_device{}()};
    std::vector<std::vector<double>> res;
    res.reserve(n);
    for ( ; n; --n) {
        std::vector<double> point;
        point.reserve(p.size());
        for (const auto t : p) {
            point.push_back(std::uniform_real_distribution<double>{t- PT_BOUND, t + PT_BOUND}(gen));
        }
        res.push_back(point);
    }
    return res;
}

Note that the random engine is static so it's only initialized once. Not only is this a more flexible function generally, it makes your original much easier to write.

Re-order the operations for better modularity

Instead of cycling through each point multiple times to create the random clustered points, you could instead create the points around each cluster first. That makes it easier to use functions like the one above. Here's how a refactored gen might look:

void Cluster::gen(unsigned int k, std::vector<std::vector<double>> &c, std::string file_out, std::string file_rpt, bool csv, bool norm) const {
    std::vector<std::vector<double>> pts;
    pts.reserve(k);
    const unsigned n = k / c.size();
    unsigned rem = k % c.size();
    for (const auto &point : c) {
        auto cloud = around(point, n + (rem ? 1 : 0));
        pts.insert(pts.end(), cloud.begin(), cloud.end());
        if (rem) 
            --rem;
    }
    print(file_out, pts, (csv ? ',' : ' '));
    report(file_rpt, c, k, norm);
}

The around() function (there's probably a better name!) is shown above. The print and report functions are each only a few lines long and quite simple.

Pass ostream& rather than file names

Instead of passing a file name as a string, it's often advantageous to use a more flexible interface by passing a std::ostream&. That allows things such as using a stringstream for output.

Reconsider the interface

At the moment, the main function has a lot of parameters:

void clustergen(unsigned int k,   // desired number of random points
                std::vector<std::vector<double>> &c,  // cluster loci
                std::string file_out,   // data file name
                std::string file_rpt,   // report file name
                bool csv,               // csv or space
                bool norm);             // norm or uniform dist

It's a lot to track. Rather than have one function do everything with multiple options, consider instead separating the generation of the points from the reporting, as I've hinted at above. Also, instead of passing a bool for csv, I'd suggest passing a separation character instead, so that if someone wanted to have, say, a tab delimited output, that could trivially be accommodated. In that same vein, but with a little more complexity, consider passing in a random function rather than only having two fixed distributions. I show how that might work in the next suggestion.

Don't unnecessarily restrict user flexibility

This goes for a lot of things already mentioned in which relatively small changes could be made to accommodate much more flexibility (and presumably usefulness) of your code. One in particular, that I thought might be worth illustrating in more detail is in passing in a function instead of having just two fixed distributions selected via a passed bool. Here's how I'd do it:

std::vector<std::vector<double>> Cluster::around(const std::vector<double> &p, 
        unsigned n, 
        std::function<double(double)> &rnd) 
{
    std::vector<std::vector<double>> res;
    res.reserve(n);
    for ( ; n; --n) {
        std::vector<double> point;
        point.reserve(p.size());
        for (const auto t : p) {
            point.push_back(rnd(t));
        }
        res.push_back(point);
    }
    return res;
}

This now uses std::function which provides a great deal of flexibility in how this is used. For example, we might want to use a multimodal distribution such that each number is normally distributed around three values \$\{ x-n, x, x+n \}\$. With \$x\$ being the original coordinate and \$n\$ being some supplied constant. Here's one way to do that:

static double my_dist(double mean, double stddev, double ringdist) {
    static std::default_random_engine gen{std::random_device{}()};
    std::bernoulli_distribution a{0.25};
    std::bernoulli_distribution b{0.5};
    if (a(gen)) {  // flip a coin
        return std::normal_distribution<double>{mean,stddev}(gen);  // inner
    }
    // outer
    return mean+(b(gen) ? 1 : -1)*std::normal_distribution<double>{ringdist,stddev}(gen);
}

You may have noticed that this function takes three parameters, while the std::function above only takes one. We can use std::bind to make that work. Here's a complete program:

int main() {
    std::vector<std::vector<double>> v = {{0,0}, {50,30}, {0,100}};
    unsigned k = 10000;
    const auto file_out{"clustergen_out.dat"};
    std::vector<std::vector<double>> pts;
    pts.reserve(k);
    const unsigned n = k / v.size();
    unsigned rem = k % v.size();
    double bound = 2;
    double ring = 10;
    std::function<double(double)> rnd{std::bind(my_dist, std::placeholders::_1, bound, ring)};
    for (const auto &point : v) {
        auto cloud = Cluster::around(point, n + (rem ? 1 : 0), rnd);
        pts.insert(pts.end(), cloud.begin(), cloud.end());
        if (rem) 
            --rem;
    }
    Cluster::print(file_out, pts, ' ');
}

Note that because we no longer need the parameters PT_BOUND or the like, all of the Cluster class member functions can be static (or alternatively, just group them in a namespace). We use std::bind to bind the function arguments and then create the requisite std::function to actuallly pass to the around function. Here's a plot of the resulting data:

I had originally thought that it would be interesting to do something like a 2-d version of an electron's radial probability function, but with this code we only get nine clumps instead of concentric rings because we're considering each coordinate individually rather than computing over the entire vector of coordinates. There are a number of ways to effect such a change, but I'll leave that to you.