示例#1
0
def test_multiphase_FE_strain():
    from pymks import MKSRegressionModel
    from pymks.datasets import make_elastic_FE_strain_delta
    from pymks.datasets import make_elastic_FE_strain_random
    from pymks.bases import DiscreteIndicatorBasis

    L = 21
    i = 3
    elastic_modulus = (80, 100, 120)
    poissons_ratio = (0.3, 0.3, 0.3)
    macro_strain = 0.02
    size = (L, L)

    X_delta, strains_delta = \
        make_elastic_FE_strain_delta(elastic_modulus=elastic_modulus,
                                     poissons_ratio=poissons_ratio,
                                     size=size, macro_strain=macro_strain)
    basis = DiscreteIndicatorBasis(len(elastic_modulus))
    MKSmodel = MKSRegressionModel(basis)
    MKSmodel.fit(X_delta, strains_delta)
    np.random.seed(99)
    X, strain = make_elastic_FE_strain_random(n_samples=1,
                                              elastic_modulus=elastic_modulus,
                                              poissons_ratio=poissons_ratio,
                                              size=size,
                                              macro_strain=macro_strain)
    strain_pred = MKSmodel.predict(X)

    assert np.allclose(strain_pred[0, i:-i],
                       strain[0, i:-i],
                       rtol=1e-2,
                       atol=6.1e-3)
示例#2
0
def test_cahn_hilliard():
    from pymks.datasets.cahn_hilliard_simulation import CahnHilliardSimulation
    from pymks.datasets import make_cahn_hilliard
    from sklearn import metrics
    from pymks import MKSRegressionModel
    from pymks import ContinuousIndicatorBasis

    mse = metrics.mean_squared_error
    n_samples = 100
    n_spaces = 20
    dt = 1e-3
    np.random.seed(0)
    X, y = make_cahn_hilliard(n_samples=n_samples,
                              size=(n_spaces, n_spaces),
                              dt=dt)
    basis = ContinuousIndicatorBasis(10, [-1, 1])
    model = MKSRegressionModel(basis)
    model.fit(X, y)
    X_test = np.array(
        [np.random.random((n_spaces, n_spaces)) for i in range(1)])
    CHSim = CahnHilliardSimulation(dt=dt)
    CHSim.run(X_test)
    y_test = CHSim.response
    y_pred = model.predict(X_test)
    assert mse(y_test[0], y_pred[0]) < 0.03
示例#3
0
def test_multiphase_FE_strain():
    from pymks import MKSRegressionModel
    from pymks.datasets import make_elastic_FE_strain_delta
    from pymks.datasets import make_elastic_FE_strain_random
    from pymks.bases import DiscreteIndicatorBasis

    L = 21
    i = 3
    elastic_modulus = (80, 100, 120)
    poissons_ratio = (0.3, 0.3, 0.3)
    macro_strain = 0.02
    size = (L, L)

    X_delta, strains_delta = \
        make_elastic_FE_strain_delta(elastic_modulus=elastic_modulus,
                                     poissons_ratio=poissons_ratio,
                                     size=size, macro_strain=macro_strain)
    basis = DiscreteIndicatorBasis(len(elastic_modulus))
    MKSmodel = MKSRegressionModel(basis)
    MKSmodel.fit(X_delta, strains_delta)
    np.random.seed(99)
    X, strain = make_elastic_FE_strain_random(n_samples=1,
                                              elastic_modulus=elastic_modulus,
                                              poissons_ratio=poissons_ratio,
                                              size=size,
                                              macro_strain=macro_strain)
    strain_pred = MKSmodel.predict(X)

    assert np.allclose(strain_pred[0, i:-i], strain[0, i:-i],
                       rtol=1e-2, atol=6.1e-3)
示例#4
0
def test_resize_pred():
    from pymks import MKSRegressionModel
    from pymks.bases import DiscreteIndicatorBasis

    nx, ny = 21, 21
    resize = 3
    X_delta, y_delta = get_delta_data(nx, ny)
    X_test, y_test = get_random_data(nx, ny)
    X_big_test, y_big_test = get_random_data(resize * nx, resize * ny)
    basis = DiscreteIndicatorBasis(n_states=2)

    model = MKSRegressionModel(basis)
    model.fit(X_delta, y_delta)
    y_pred = model.predict(X_test)
    assert np.allclose(y_pred, y_test, rtol=1e-2, atol=6.1e-3)
    model.resize_coeff((resize * nx, resize * ny))
    y_big_pred = model.predict(X_big_test)
    assert np.allclose(y_big_pred, y_big_test, rtol=1e-2, atol=6.1e-2)
示例#5
0
def test_resize_pred():
    from pymks import MKSRegressionModel
    from pymks.bases import DiscreteIndicatorBasis

    nx, ny = 21, 21
    resize = 3
    X_delta, y_delta = get_delta_data(nx, ny)
    X_test, y_test = get_random_data(nx, ny)
    X_big_test, y_big_test = get_random_data(resize * nx, resize * ny)
    basis = DiscreteIndicatorBasis(n_states=2)

    model = MKSRegressionModel(basis)
    model.fit(X_delta, y_delta)
    y_pred = model.predict(X_test)
    assert np.allclose(y_pred, y_test, rtol=1e-2, atol=6.1e-3)
    model.resize_coeff((resize * nx, resize * ny))
    y_big_pred = model.predict(X_big_test)
    assert np.allclose(y_big_pred, y_big_test, rtol=1e-2, atol=6.1e-2)
示例#6
0
def test_MKS_elastic_delta():
    from pymks import MKSRegressionModel
    from pymks.bases import DiscreteIndicatorBasis
    nx, ny = 21, 21
    X, y_test = get_delta_data(nx, ny)
    basis = DiscreteIndicatorBasis(n_states=2)
    model = MKSRegressionModel(basis)
    model.fit(X, y_test)
    y_pred = model.predict(X)
    assert np.allclose(y_pred, y_test, rtol=1e-3, atol=1e-3)
示例#7
0
def test_MKS_elastic_delta():
    from pymks import MKSRegressionModel
    from pymks.bases import DiscreteIndicatorBasis
    nx, ny = 21, 21
    X, y_test = get_delta_data(nx, ny)
    basis = DiscreteIndicatorBasis(n_states=2)
    model = MKSRegressionModel(basis)
    model.fit(X, y_test)
    y_pred = model.predict(X)
    assert np.allclose(y_pred, y_test, rtol=1e-3, atol=1e-3)
示例#8
0
文件: test.py 项目: tonyfast/pymks
def test_cahn_hilliard():
    from pymks.datasets.cahn_hilliard_simulation import CahnHilliardSimulation
    from pymks.datasets import make_cahn_hilliard
    from sklearn import metrics
    from pymks import MKSRegressionModel
    from pymks import ContinuousIndicatorBasis
    
    mse = metrics.mean_squared_error
    n_samples = 100
    n_spaces = 20
    dt = 1e-3
    np.random.seed(0)
    X, y = make_cahn_hilliard(n_samples=n_samples,
                              size=(n_spaces, n_spaces), dt=dt)
    basis = ContinuousIndicatorBasis(10, [-1, 1])
    model = MKSRegressionModel(basis)
    model.fit(X, y)
    X_test = np.array([np.random.random((n_spaces, n_spaces)) for i in range(1)])
    CHSim = CahnHilliardSimulation(dt=dt)
    CHSim.run(X_test)
    y_test = CHSim.response
    y_pred = model.predict(X_test)
    assert mse(y_test, y_pred) < 0.03
示例#9
0
def make_elastic_stress_random(n_samples=[10, 10],
                               elastic_modulus=(100, 150),
                               poissons_ratio=(0.3, 0.3),
                               size=(21, 21),
                               macro_strain=0.01,
                               grain_size=[(3, 3), (9, 9)],
                               seed=10,
                               volume_fraction=None,
                               percent_variance=None):
    """
    Generates microstructures and their macroscopic stress values for an
    applied macroscopic strain.

    Args:
        n_samples (int, optional): number of samples
        elastic_modulus (tuple, optional): list of elastic moduli for the
            different phases.
        poissons_ratio (tuple, optional): list of poisson's ratio values for
            the phases.
        size (tuple, optional): size of the microstructures
        macro_strain (tuple, optional): macroscopic strain applied to the
            sample.
        grain_size (tuple, optional): effective dimensions of grains
        seed (int, optional): seed for random number generator
        volume_fraction(tuple, optional): specify the volume fraction of
            each phase
        percent_variance(int, optional): Only used if volume_fraction is
            specified. Randomly varies the volume fraction of the
            microstructure.


    Returns:
        array of microstructures with dimensions (n_samples, n_x, ...) and
        effective stress values

    """
    if not isinstance(grain_size[0], (list, tuple, np.ndarray)):
        grain_size = (grain_size, )
    if not isinstance(n_samples, (list, tuple, np.ndarray)):
        n_samples = (n_samples, )
    if volume_fraction is None:
        volume_fraction = (None, ) * len(n_samples)
    vf_0 = volume_fraction[0]
    if not isinstance(vf_0, (list, tuple, np.ndarray)) and vf_0 is not None:
        volume_fraction = (volume_fraction, )
        np.random.seed(seed)
    if not isinstance(size, (list, tuple, np.ndarray)) or len(size) > 3:
        raise RuntimeError('size must have length of 2 or 3')
    [
        RuntimeError('dimensions of size and grain_size are not the same.')
        for grains in grain_size if len(size) != len(grains)
    ]
    if vf_0 is not None:
        [
            RuntimeError('dimensions of size and grain_size are not the same.')
            for volume_frac in volume_fraction
            if len(elastic_modulus) != len(volume_frac)
        ]
    if len(elastic_modulus) != len(poissons_ratio):
        raise RuntimeError('length of elastic_modulus and poissons_ratio are' \
                           'not the same.')
    np.random.seed(seed)
    seed = np.random.randint(100, size=(len(volume_fraction), ))
    X_cal, y_cal = make_elastic_FE_strain_delta(elastic_modulus,
                                                poissons_ratio, size,
                                                macro_strain)
    n_states = len(elastic_modulus)
    basis = DiscreteIndicatorBasis(n_states)
    model = MKSRegressionModel(basis=basis)
    model.fit(X_cal, y_cal)
    X = np.concatenate([
        make_microstructure(n_samples=sample,
                            size=size,
                            n_phases=n_states,
                            grain_size=gs,
                            seed=s,
                            volume_fraction=vf,
                            percent_variance=percent_variance) for vf, s, gs,
        sample in zip(volume_fraction, seed, grain_size, n_samples)
    ])
    X_ = basis.discretize(X)
    index = tuple([None for i in range(len(size) + 1)]) + (slice(None), )
    modulus = np.sum(X_ * np.array(elastic_modulus)[index], axis=-1)
    y_stress = model.predict(X) * modulus
    return X, np.average(y_stress.reshape(len(y_stress), -1), axis=1)
示例#10
0
def make_elastic_stress_random(n_samples=[10, 10], elastic_modulus=(100, 150),
                               poissons_ratio=(0.3, 0.3), size=(21, 21),
                               macro_strain=0.01, grain_size=[(3, 3), (9, 9)],
                               seed=10, volume_fraction=None,
                               percent_variance=None):
    """
    Generates microstructures and their macroscopic stress values for an
    applied macroscopic strain.

    Args:
        n_samples (int, optional): number of samples
        elastic_modulus (tuple, optional): list of elastic moduli for the
            different phases.
        poissons_ratio (tuple, optional): list of poisson's ratio values for
            the phases.
        size (tuple, optional): size of the microstructures
        macro_strain (tuple, optional): macroscopic strain applied to the
            sample.
        grain_size (tuple, optional): effective dimensions of grains
        seed (int, optional): seed for random number generator
        volume_fraction(tuple, optional): specify the volume fraction of
            each phase
        percent_variance(int, optional): Only used if volume_fraction is
            specified. Randomly varies the volume fraction of the
            microstructure.


    Returns:
        array of microstructures with dimensions (n_samples, n_x, ...) and
        effective stress values

    Example

    >>> X, y = make_elastic_stress_random(n_samples=1, elastic_modulus=(1, 1),
    ...                                   poissons_ratio=(1, 1),
    ...                                   grain_size=(3, 3), macro_strain=1.0)
    >>> assert np.allclose(y, np.ones(y.shape))
    >>> X, y = make_elastic_stress_random(n_samples=1, grain_size=(1, 1),
    ...                                   elastic_modulus=(100, 200),
    ...                                   size=(2, 2), poissons_ratio=(1, 3),
    ...                                   macro_strain=1., seed=3)
    >>> X_result = np.array([[[1, 1],
    ...                       [0, 1]]])
    >>> assert np.allclose(X, X_result)
    >>> assert float(np.round(y, decimals=5)[0]) == 228.74696
    >>> X, y = make_elastic_stress_random(n_samples=1, grain_size=(1, 1, 1),
    ...                                   elastic_modulus=(100, 200),
    ...                                   poissons_ratio=(1, 3),  seed=3,
    ...                                   macro_strain=1., size=(2, 2, 2))
    >>> X_result = np.array([[[1, 1],
    ...                       [0, 0]],
    ...                      [[1, 1],
    ...                       [0, 0]]])
    >>> assert np.allclose(X, X_result)
    >>> assert np.round(y[0]).astype(int) == 150

    """
    if not isinstance(grain_size[0], (list, tuple, np.ndarray)):
        grain_size = (grain_size,)
    if not isinstance(n_samples, (list, tuple, np.ndarray)):
        n_samples = (n_samples,)
    if volume_fraction is None:
        volume_fraction = (None,) * len(n_samples)
    vf_0 = volume_fraction[0]
    if not isinstance(vf_0, (list, tuple, np.ndarray)) and vf_0 is not None:
        volume_fraction = (volume_fraction,)
    if not isinstance(size, (list, tuple, np.ndarray)) or len(size) > 3:
        raise RuntimeError('size must have length of 2 or 3')
    [RuntimeError('dimensions of size and grain_size are not the same.')
     for grains in grain_size if len(size) != len(grains)]
    if vf_0 is not None:
        [RuntimeError('dimensions of size and grain_size are not the same.')
         for volume_frac in volume_fraction
         if len(elastic_modulus) != len(volume_frac)]
    if len(elastic_modulus) != len(poissons_ratio):
        raise RuntimeError('length of elastic_modulus and poissons_ratio are \
                           not the same.')
    X_cal, y_cal = make_elastic_FE_strain_delta(elastic_modulus,
                                                poissons_ratio, size,
                                                macro_strain)
    n_states = len(elastic_modulus)
    basis = DiscreteIndicatorBasis(n_states)
    model = MKSRegressionModel(basis=basis)
    model.fit(X_cal, y_cal)
    X = np.concatenate([make_microstructure(n_samples=sample, size=size,
                                            n_phases=n_states,
                                            grain_size=gs, seed=seed,
                                            volume_fraction=vf,
                                            percent_variance=percent_variance)
                        for vf, gs, sample in zip(volume_fraction,
                                                  grain_size, n_samples)])
    X_ = basis.discretize(X)
    index = tuple([None for i in range(len(size) + 1)]) + (slice(None),)
    modulus = np.sum(X_ * np.array(elastic_modulus)[index], axis=-1)
    y_stress = model.predict(X) * modulus
    return X, np.average(y_stress.reshape(len(y_stress), -1), axis=1)
示例#11
0
文件: __init__.py 项目: yabansu/pymks
def make_elastic_stress_random(n_samples=[10, 10], elastic_modulus=(100, 150),
                               poissons_ratio=(0.3, 0.3), size=(21, 21),
                               macro_strain=0.01, grain_size=[(3, 3), (9, 9)],
                               seed=10):
    """
    Generates microstructures and their macroscopic stress values for an
    applied macroscopic strain.

    Args:
        n_samples (int, optional): number of samples
        elastic_modulus (tuple, optional): list of elastic moduli for the
            different phases.
        poissons_ratio (tuple, optional): list of poisson's ratio values for
            the phases.
        size (tuple, optional): size of the microstructures
        macro_strain (tuple, optional): macroscopic strain applied to the
            sample.
        grain_size (tuple, optional): effective dimensions of grains
        seed (int, optional): seed for random number generator

    Returns:
        array of microstructures with dimensions (n_samples, n_x, ...) and
        effective stress values

    Example

    >>> X, y = make_elastic_stress_random(n_samples=1, elastic_modulus=(1, 1),
    ...                                   poissons_ratio=(1, 1),
    ...                                   grain_size=(3, 3), macro_strain=1.0)
    >>> assert np.allclose(y, np.ones(y.shape))
    >>> X, y = make_elastic_stress_random(n_samples=1, grain_size=(1, 1),
    ...                                   elastic_modulus=(100, 200),
    ...                                   size=(2, 2), poissons_ratio=(1, 3),
    ...                                   macro_strain=1., seed=3)
    >>> X_result = np.array([[[1, 1],
    ...                       [0, 1]]])
    >>> assert np.allclose(X, X_result)
    >>> assert float(np.round(y, decimals=5)[0]) == 228.74696
    >>> X, y = make_elastic_stress_random(n_samples=1, grain_size=(1, 1, 1),
    ...                                   elastic_modulus=(100, 200),
    ...                                   poissons_ratio=(1, 3),  seed=3,
    ...                                   macro_strain=1., size=(2, 2, 2))
    >>> X_result = np.array([[[1, 1],
    ...                       [0, 0]],
    ...                      [[1, 1],
    ...                       [0, 0]]])
    >>> assert np.allclose(X, X_result)
    >>> assert np.round(y[0]).astype(int) == 150

    """
    if not isinstance(grain_size[0], (list, tuple, np.ndarray)):
        grain_size = (grain_size,)
    if not isinstance(n_samples, (list, tuple, np.ndarray)):
        n_samples = (n_samples,)
    if not isinstance(size, (list, tuple, np.ndarray)) or len(size) > 3:
        raise RuntimeError('size must have length of 2 or 3')
    [RuntimeError('dimensions of size and grain_size are not the same.')
     for grains in grain_size if len(size) != len(grains)]
    if len(elastic_modulus) != len(poissons_ratio):
        raise RuntimeError('length of elastic_modulus and poissons_ratio are \
                           not the same.')
    X_cal, y_cal = make_elastic_FE_strain_delta(elastic_modulus,
                                                poissons_ratio, size,
                                                macro_strain)
    n_states = len(elastic_modulus)
    basis = DiscreteIndicatorBasis(n_states)
    model = MKSRegressionModel(basis=basis)
    model.fit(X_cal, y_cal)
    X = np.concatenate([make_microstructure(n_samples=sample, size=size,
                                            n_phases=n_states,
                                            grain_size=gs, seed=seed) for gs,
                        sample in zip(grain_size, n_samples)])
    X_ = basis.discretize(X)
    index = tuple([None for i in range(len(size) + 1)]) + (slice(None),)
    modulus = np.sum(X_ * np.array(elastic_modulus)[index], axis=-1)
    y_stress = model.predict(X) * modulus
    return X, np.average(y_stress.reshape(np.sum(n_samples), y_stress[0].size),
                         axis=1)