Scaling

Cratermaker’s Scaling component provides tools to convert Projectile parameters (e.g., projectile diameter, velocity, angle, density), and Target properties (material type, surface gravity, density) into a final crater diameter. It also categorizes craters by their morphology: simple, transitional, or complex. There are two scaling models available: “montecarlo” and “ctem”. The “ctem” model closely resembles the model used in the CTEM code, a Fortran-based ancestor of CTEM. The “montecarlo” model is a newer non-deterministic model that includes the intrinsic variability in projectile to crater size scaling relationships. We have also included updated simple-to-complex transition diameter values from Schenk et al. (2021) that incorporate data from Vesta and Ceres from the Dawn mission.

Setting up a Scaling object

As discussed in the defaults section, all Cratermaker components have a default configuration that is set when no arguments are passed to the Scaling.maker() method. We can inspect the defaults for Scaling:

In [1]: from cratermaker import Scaling

In [2]: scaling = Scaling.maker()

In [3]: print(scaling)
<MonteCarloScaling>
Target: Moon
Projectile: <asteroids>
Material: Soft Rock
K1: 0.200
mu: 0.550
Ybar: 7.600 MPa
Target density: 2250 kg/m³
Projectile density: 2250 kg/m³
Nominal simple-complex transition diameter: 12.19 km
Monte Carlo Scaling: True

We can see that default scaling model is “montecarlo” and that the Scaling object contains a Target (which defaults to “Moon”) and a Projectile (which defaults to “asteroids”). The other properties, such as target and projectile densities, target material, and the scaling parameters, were set based on the specific target and projectile types that were chosen. We can explore what happens when we pass other options to the model:

In [4]: scaling = Scaling.maker("ctem", target="Mars", projectile="comets")

In [5]: print(scaling)
<CTEMScaling>
Target: Mars
Projectile: <comets>
Material: Soft Rock
K1: 0.200
mu: 0.550
Ybar: 7.600 MPa
Target density: 2250 kg/m³
Projectile density: 500 kg/m³
Nominal simple-complex transition diameter: 4.263 km
Monte Carlo Scaling: False

Typically a scaling object would not be used on its own, but instead as an object that gets passed to Crater.maker(). However, we can still use it on its own and see how it is constructed and used.

You can also override the default materials that are associated with target bodies. For instance the default material for Mars is “Soft Rock”, but we could override this with something else, like “sand” or “ice”:

In [6]: print(Scaling.maker(target="Mars", material="sand"))
<MonteCarloScaling>
Target: Mars
Projectile: <asteroids>
Material: Sand
K1: 0.240
mu: 0.410
Ybar: 0 Pa
Target density: 2250 kg/m³
Projectile density: 2250 kg/m³
Nominal simple-complex transition diameter: 7.727 km
Monte Carlo Scaling: True


In [7]: print()


In [8]: print(Scaling.maker(target="Mars", material="ice"))
<MonteCarloScaling>
Target: Mars
Projectile: <asteroids>
Material: Ice
K1: 15.625
mu: 0.480
Ybar: 0 Pa
Target density: 2250 kg/m³
Projectile density: 2250 kg/m³
Nominal simple-complex transition diameter: 7.727 km
Monte Carlo Scaling: True

You can also adjust individual scaling parameters manually:

In [9]: print(Scaling.maker(target="Moon", Ybar=1e7))
<MonteCarloScaling>
Target: Moon
Projectile: <asteroids>
Material: Soft Rock
K1: 0.200
mu: 0.550
Ybar: 10.00 MPa
Target density: 2250 kg/m³
Projectile density: 2250 kg/m³
Nominal simple-complex transition diameter: 12.19 km
Monte Carlo Scaling: True

You are not limited to using pre-defined materials. For instance, you can specify your own materials with unique properties, but you must specify all of the parameters required by the given model. Both scaling models available in Cratermaker use the same set of required parameters (K1, mu, Ybar, and density), and these must all be set. See Richardson (2009) and Holsapple (1993) for details on the scaling model parameters.

In [10]: print(Scaling.maker(material="Flubber", K1=3.8, mu=0.1, Ybar=1e7, density=1500.0))
<MonteCarloScaling>
Target: Moon
Projectile: <asteroids>
Material: Flubber
K1: 3.800
mu: 0.100
Ybar: 10.00 MPa
Target density: 1500 kg/m³
Projectile density: 2250 kg/m³
Nominal simple-complex transition diameter: 12.19 km
Monte Carlo Scaling: True

Using the Scaling object

Once you have a scaling object, you can use it to compute between projectile, transient, and final crater sizes. Any Scaling model will come with the following methods:

• projectile_to_transient(): Takes the projectile diameter and returns the transient crater diameter.

• transient_to_projectile(): Takes the transient crater diameter and returns the projectile diameter.

• transient_to_final(): Takes the transient crater diameter and returns both the final crater diameter and the morphology type.

• final_to_transient(): Takes the final crater diameter and returns the transient crater diameter. Optionally, you can also provide the morphology type, but if you don’t provide it, it will be computed (though it might not be the same as the one used to create the final crater!)

In [11]: scaling = Scaling.maker()

In [12]: dt = scaling.projectile_to_transient(1000.0)

In [13]: print(f"1 km projectile -> Transient crater: {dt*1e-3:.2f} km")
1 km projectile -> Transient crater: 12.17 km

In [14]: df, mt = scaling.transient_to_final(dt)

In [15]: print(f"1 km projectile -> Final crater: {df*1e-3:.2f} km, Morphology type: {mt}")
1 km projectile -> Final crater: 15.72 km, Morphology type: transitional

In [16]: dt, mt = scaling.final_to_transient(df, mt)

In [17]: print(f"Final crater -> Transient: {dt*1e-3:.2f} km")
Final crater -> Transient: 12.17 km

In [18]: pd = scaling.transient_to_projectile(dt)

In [19]: print(f"Final crater -> projectile: {pd*1e-3:.3f} km")
Final crater -> projectile: 1.000 km

Because the scaling model is probabilistic, the results will vary slightly each time you run it. This is particualrly true when the crater size is near the simple-to-complex transition. Remember how passing the morphology type to final_to_transient() is optional? In the above example we used the morphology type that was returned from the transient_to_final() method. If we had not passed it, the final_to_transient() method would have computed it again, and it might not be the same as the one used to create the final crater. Here is an example showing this effect:

In [20]: scaling = Scaling.maker(rng_seed=3098351)

In [21]: pd_in = 800.0

In [22]: dt = scaling.projectile_to_transient(pd_in)

In [23]: df, mt_in = scaling.transient_to_final(dt)

In [24]: dt, mt_out = scaling.final_to_transient(df)

In [25]: pd_out = scaling.transient_to_projectile(dt)

In [26]: print(f"Transient -> Final morphology: {mt_in}")
Transient -> Final morphology: transitional

In [27]: print(f"Final -> Transient morphology: {mt_out}")
Final -> Transient morphology: simple

In [28]: print(f"Input projectile diameter  : {pd_in*1e-3:.3f} km")
Input projectile diameter  : 0.800 km

In [29]: print(f"Output projectile diameter : {pd_out*1e-3:.3f} km")
Output projectile diameter : 0.798 km

More Scaling examples

See more examples at Projectiles and Scaling