Fluids/Kernel.cs at main · jameswu5/Fluids · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
using System;

namespace Fluids;

public abstract class Kernel
{
    public enum Type { Polynomial, Spiky, Viscous }

    public static Kernel Create(Type type)
    {
        return type switch
        {
            Type.Polynomial => new Polynomial(),
            Type.Spiky => new Spiky(),
            Type.Viscous => new Viscous(),
            _ => throw new NotImplementedException()
        };
    }

    public static bool Validate(float distance, float radius)
    {
        return distance >= 0 && distance <= radius;
    }

    public abstract float Evaluate(float distance, float radius);
    public abstract float Derivative(float distance, float radius);
    public abstract float Laplacian(float distance, float radius);
}

public class Polynomial : Kernel
{
    public override float Evaluate(float distance, float radius)
    {
        if (!Validate(distance, radius)) return 0;

        return 315f / (64f * MathF.PI * MathF.Pow(radius, 9)) * MathF.Pow(radius * radius - distance * distance, 3);
    }

    public override float Derivative(float distance, float radius)
    {
        if (!Validate(distance, radius)) return 0;

        return -945f / (32f * MathF.PI * MathF.Pow(radius, 9)) * distance * MathF.Pow(radius * radius - distance * distance, 2);
    }

    public override float Laplacian(float distance, float radius)
    {
        if (!Validate(distance, radius)) return 0;

        return 945f / (8f * MathF.PI * MathF.Pow(radius, 9)) * (radius * radius - distance * distance);
    }
}

public class Spiky : Kernel
{
    public override float Evaluate(float distance, float radius)
    {
        if (!Validate(distance, radius)) return 0;

        float scale = 15 / (2 * MathF.PI * MathF.Pow(radius, 5));
        float v = radius - distance;
        return v * v * scale;

    }

    public override float Derivative(float distance, float radius)
    {
        if (!Validate(distance, radius)) return 0;

        float scale = 15 / (MathF.Pow(radius, 5) * MathF.PI);
		float v = radius - distance;
		return -v * scale;
    }

    public override float Laplacian(float distance, float radius)
    {
        throw new NotImplementedException();
    }
}

public class Viscous : Kernel
{
    public override float Evaluate(float distance, float radius)
    {
        throw new NotImplementedException();
    }

    public override float Derivative(float distance, float radius)
    {
        throw new NotImplementedException();
    }

    public override float Laplacian(float distance, float radius)
    {
        if (!Validate(distance, radius)) return 0;

        return 45f / (MathF.PI * MathF.Pow(radius, 6)) * (radius - distance);
    }
}