# Implementation of NASA Breakup model Area to Mass distribution

In the research "NASA's new breakup model of evolve 4.0" the implementation for the area to mass distribution of fragments produced by collisions and explosions is provided.

The distribution is defined as follows:

$$\mu$$ is defined as the mean,
$$\sigma$$ is defined as the standard deviation,
$$\alpha$$ is the scaling factor,
$$\lambda_{c}$$ is the log10(length characteristic)

When implementing this distribution, say in python, would it be appropriate to add the scaled normal probability distribution functions together? Or do I sample each normal distribution for a value, scale them and add them together?

Any help would be much appreciated as this problem as been causing me problems for more than a week.

EDIT: My question is about implementing this in python.The first way to implement it would be to use numpy to generate a random value in each normal distribution using np.random.normal() so I would define the expression as alpha * np.random.normal(...) + (1 - alpha) * np.random.normal().

Alternatively I could use SciPy to compute the probability density functions of the normal distributions and add those, alpha * norm.pdf(...) + (1 - alpha) * norm.pdf(...). I'm unsure about which of these methods would result in the proper implementation.

• Could you add a little more clarifying information to your post? You ask "would it be appropriate to add the scaled normal probability distribution functions together?" - since that's how it is defined in the paper, yes, it would be appropriate, but I suspect your question is more about the python implementation of this. – Chris Jun 15 at 17:36
• Thanks for the answer! My question is about implementing this in python.The first way to implement it would be to use numpy to generate a random value in each normal distribution using np.random.normal() so I would define the expression as alpha * np.random.normal(...) + (1 - alpha) * np.random.normal(). Alternatively I could use SciPy to compute the probability density functions of the normal distributions and add those, alpha * norm.pdf(...) + (1 - alpha) * norm.pdf(...). I'm unsure about which of these methods would result in the proper implementation. – Reece Humphreys Jun 15 at 18:50
• Cool question! When you get a chance go ahead and add that clarification back into your question post. Some readers will not check comments and they should be considered temporary and can be deleted without warning. Thanks! – uhoh Jun 16 at 1:22

Was able to figure out how to achieve this. Alpha acts like a probability of which normal distribution to use. As such use a array to switch the values depending on the probability as follows:

# Creates a array of tuples, where the first value is mean 1, and the second is mean 2
mean_preSwitch = np.array(mean_AM(lambda_c))

# Generate a uniform distribution between 0 and 1, with a value sampled for each fragment in the breakup model
switch = np.random.uniform(0,1, N_fragments)

# Use the fact that alpha is a probability of each distribution to create a new list of means that follows the probability determined by alpha
means = np.empty(N_fragments_total)
I,J = switch<alpha, switch>=alpha
means[I] = mean_preSwitch[0, I]
means[J] = mean_preSwitch[1, J]

# Do the same thing for standard deviation
std_dev_preSwitch = np.array(std_dev_AM(lambda_c))

devs = np.empty(N_fragments_total)
devs[I] = std_dev_preSwitch[0, I]
devs[J] = std_dev_preSwitch[1, J]

# Finally pull samples from the resulting normal distribution as follows
distribution = np.random.normal(means, devs, N_fragments_total)]



Implementing the area to mass ratio like this in python results in values that are similar to the ESA, and NASA implementation and as such can be used for predicting the area to mass ratio for the fragments produced in an orbital collision.