Can I free mallocs that are being generated in every step of a recursion in C?

You're supposed to free memory right after the last time it will be used. In your program, after the while loop in recursion, Energy isn't used again, so you should free it right after that (i.e., right before return event_counter;).

Joseph Sible-Reinstate Monica is correct about the question you asked. But your code can be improved in a number of areas. If you want to see the final version, you should scroll all the way to the bottom of my answer for run_simulation, which is a dramatically better version of your recursion function.

Let's start with your initial function, evolution. If you want to allocate memory and initialize all bytes to 0, you should use the calloc function rather than malloc. Instead of

double * energy_vec = malloc(sizeof(double)*50);
for(int i = 0; i < 50; i++){ // your original i <= 50 was wrong
    energy_vec[i] = 0;
}

you should instead do

double * energy_vec = calloc(50 * sizeof(double));

This is usually more efficient than malloc + manually setting everything to 0, and it's more readable.

Second, there is no reason for recursion to return a double except. The most logical thing for recursion to return would be an unsigned int, since it will always return a nonnegative integer. This is practically a drop-in replacement; just change the return type and the type of event_counter to unsigned int, and your code will work just fine without pointlessly returning a double. I will make this switch - for now.

Third, a double can be larger than 2^50. In the event that this happens, your energy array isn't going to be big enough. This is a serious problem, but it could be averted by dynamically resizing the array. A higher-level high-performance language like Rust or C++ would provide you with resizable arrays as part of the standard library, but in C, you'd have to do it by hand.

Fourth, you in fact do not need dynamic memory allocation at all because your code can be done with mathematics. You can actually get away with not having loops at all! However, to avoid using "floating point black magic", I will use loops in my answer. We first define

unsigned int count_divisions(double d) {
    unsigned int count;
    for (count = 0; d > 1.0; d /= 2, count++);
    return count;
}

Note that count_divisions(d) is exactly equal to the conceptual length of evolution(d).

Now, we should note that the only properties we actually care about for our Doubles is there count_divisions value. It's the only thing we use. Thus, everywhere I see a double, I will replace it with its count_divisions value. The resulting code looks like this:

unsigned int * evolution(unsigned int divisions){
    unsigned int * Energy = malloc(divisions * sizeof(*Energy));
    for(unsigned int i = 0; i < divisions; i++) {
        Energy[i] = divisions - i - 1;
    }
    return Energy;
}

unsigned int recursion(unsigned int divisions) {
    unsigned int* energy_vec = evolution(divisions);
    unsigned int count = divisions;
    for (unsigned int j = 0; j < divisions; j++) {
        count += recursion(energy_vec[j]);
    }
    free(energy_vec);
    return count;
}

Now, we're beginning to approach the answer. But notice that we actually already know what energy_vec[j] is for each j; it will be divisions - j - 1. So we can completely eliminate the energy_vec vector and get the following code:

unsigned int recursion(unsigned int divisions) {
    unsigned int* energy_vec = evolution(divisions);
    unsigned int count = divisions;
    for (unsigned int j = 0; j < divisions; j++) {
        count += recursion(divisions - j - 1);
    }
    return count;
}

which we can trivially rewrite as

unsigned int recursion(unsigned int divisions) {
    unsigned int* energy_vec = evolution(divisions);
    unsigned int count = 0;
    for (unsigned int j = 0; j < divisions; j++) {
        count += recursion(j);
    }
    return count + divisions;
}

Now, we must use a bit of cleverness to deduce a better recurrence relation for recursion. It turns out that it is possible to show that recursion(0) = 0 and that recursion(k + 1) = 2 * recursion(k) + 1. This is because

recursion(k + 1) 
= recursion(0) + recursion(1) + ... + recursion(k) + k + 1
= (recursion(0) + recursion(1) + ... + recursion(k - 1) + k) + recursion(k) + 1
= recursion(k) + recursion(k) + 1
= 2 * recursion(k) + 1

Therefore, we can easily prove by induction that recursion(k) = 2^k - 1.

So in fact, you're taking in the value initial_energy and returning 2^(ceil(log(initial_energy))) - 1.

A final solution could thus be

double run_simulation(double initial_energy) {
    double power_of_two = 1;
    while (initial_energy > 1) {
        power_of_two *= 2;
        initial_energy /= 2;
    }
    return power_of_two - 1;
}

which replaces your original recursion function at much less cost.