def METHOD_NAME(
    name: str,
    dimension: int,
    bounding_method: str = "bouncing",
    rolling: bool = False,
    as_tuple: bool = False,
) -> ng.p.Parameter:
    """Creates appropriate parametrization for a Photonics problem
    Parameters
    name: str
        problem name, among bragg, chirped, cf_photosic_realistic, cf_photosic_reference and morpho
    dimension: int
        size of the problem among 16, 40 and 60 (morpho) or 80 (bragg and chirped)
    bounding_method: str
        transform type for the bounding ("arctan", "tanh", "bouncing" or "clipping"see `Array.bounded`)
    as_tuple: bool
        whether we should use a Tuple of Array instead of a 2D-array.
    Returns
    -------
    Instrumentation
        the parametrization for the problem
    """
    if name == "bragg":
        shape = (2, dimension // 2)
        bounds = [(2, 3), (30, 180)]
    elif name == "cf_photosic_realistic":
        shape = (2, dimension // 2)
        bounds = [(1, 9), (30, 180)]
    elif name == "cf_photosic_reference":
        shape = (1, dimension)
        bounds = [(30, 180)]
    elif name == "chirped":
        shape = (1, dimension)
        bounds = [(30, 180)]
    elif name == "morpho":
        shape = (4, dimension // 4)
        bounds = [(0, 300), (0, 600), (30, 600), (0, 300)]
    else:
        raise NotImplementedError(f"Transform for {name} is not implemented")
    divisor = max(2, len(bounds))
    assert not dimension % divisor, f"points length should be a multiple of {divisor}, got {dimension}"
    assert (
        shape[0] * shape[1] == dimension
    ), f"Cannot work with dimension {dimension} for {name}: not divisible by {shape[0]}."
    b_array = np.array(bounds)
    assert b_array.shape[0] == shape[0]  # pylint: disable=unsubscriptable-object
    ones = np.ones((1, int(shape[1])))
    init = np.sum(b_array, axis=1, keepdims=True).dot(ones) / 2  # type: ignore
    if as_tuple:
        instrum = ng.p.Instrumentation(
            *[
                ng.p.Array(init=init[:, i]).set_bounds(
                    b_array[:, 0], b_array[:, 1], method=bounding_method, full_range_sampling=True
                )
                for i in range(init.shape[1])  # type: ignore
            ]
        ).set_name("as_tuple")
        assert instrum.dimension == dimension, instrum
        return instrum
    array = ng.p.Array(init=init)  # type: ignore
    if bounding_method not in ("arctan", "tanh"):
        # sigma must be adapted for clipping and constraint methods
        sigma = ng.p.Array(init=[[10.0]] if name != "bragg" else [[0.03], [10.0]]).set_mutation(exponent=2.0)  # type: ignore
        array.set_mutation(sigma=sigma)
    if rolling:
        mutation = mutations.MutationChoice([mutations.Cauchy(), mutations.Translation(axis=1)])
        array = mutation(array)
    array.set_bounds(b_array[:, [0]], b_array[:, [1]], method=bounding_method, full_range_sampling=True)
    array = ng.ops.mutations.Crossover(axis=1)(array).set_name("")
    assert array.dimension == dimension, f"Unexpected {array} for dimension {dimension}"
    return array