SpringForge/spring.py at main · Bi1ku/SpringForge · 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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
from vpython import *
from constants import SPRING_LEFT_X, SPRING_STRETCHED_START_LENGTH


class Spring:
    def __init__(self, length, radius, spr_wheel_dist, spr_const, small_angle=True):
        self.spr_const = spr_const
        self.length = length  # natural length
        self.lever_arm_length = abs(spr_wheel_dist)
        self.left_y_level = spr_wheel_dist
        self.lever_arm = vector(0, spr_wheel_dist, 0)

        self.axis = vec(1, 0, 0)  # POSITIVE X
        self.small_angle = small_angle
        # self.arrow = arrow(pos = self.lever_arm, axis = norm(-1 * ((self.spr_const * self.lever_arm_length) * self.axis)) * 100, shaftwidth = 10)

        self.radius = radius

        # Spring length is the strecthed length, not the natural length
        self.spring = helix(pos=vec(SPRING_LEFT_X, self.left_y_level, 0),axis=self.axis,color=color.cyan,radius=radius,length=(SPRING_STRETCHED_START_LENGTH),coils=length / radius)

        #self.lever = helix(
        #         pos=vec(0,0,0),
        #         axis=self.lever_arm,
        #         color=color.cyan,
        #         radius=self.radius,
        #         length=(self.lever_arm_length),
        #         coils=self.length / self.radius,
        #)

    def change_config(self, evt, num=0, theta=0):
        changed_num = num if num == 0 else int(evt.id[-1])
        if "spr_const" in evt.id and changed_num == num:
            self.spr_const = evt.value
        if "spr_nat_len" in evt.id and changed_num == num:
            self.length = evt.value
        elif "spr_wheel_dist_y" in evt.id and changed_num == num:
            self.change_vertical_spr_wheel_dist(evt.value)
        elif "spr_wheel_dist_x" in evt.id and changed_num == num:
            self.change_horizontal_spr_wheel_dist(evt.value)
        elif "d_theta" in evt.id:
            self.update_position(theta)
        elif evt.id == "small_angle":
            self.small_angle = evt.checked

    def change_vertical_spr_wheel_dist(self, value):
        self.spring.pos = vec(SPRING_LEFT_X, value, 0)
        prev_x = self.lever_arm.x
        self.lever_arm = vec(prev_x, value, 0)
        self.lever_arm_length = sqrt(pow(prev_x, 2) + pow(value, 2))
        self.left_y_level = value
        #self.lever.visible = False
        #self.lever = helix(
        #         pos=vec(0, 0, 0),
        #         axis=self.lever_arm,
        #         color=color.cyan,
        #         radius=self.radius,
        #         length=(self.lever_arm_length),
        #         coils=self.length / self.radius,
        #)

    def change_horizontal_spr_wheel_dist(self, value):
        prev_y = self.lever_arm.y
        self.lever_arm = vec(value, prev_y, 0)
        self.lever_arm_length = sqrt(pow(value, 2) + pow(prev_y, 2))
        prev_spring_length = self.spring.length
        self.spring.length = SPRING_STRETCHED_START_LENGTH + value
        self.spring.coils = self.spring.length / self.radius
        #self.lever.visible = False
        #self.lever = helix(
        #         pos=vec(0, 0, 0),
        #         axis=self.lever_arm,
        #         color=color.cyan,
        #         radius=self.radius,
        #         length=(self.lever_arm_length),
        #         coils=self.length / self.radius,
        #)

    def update_position(self, theta):
        if self.small_angle:
            if self.spring.pos.y < 0:
                self.spring.length += -theta * self.lever_arm_length
                self.lever_arm = rotate(self.lever_arm, angle=-theta, axis=vector(0, 0, 1))
            else:
                self.spring.length += theta * self.lever_arm_length
                self.lever_arm = rotate(self.lever_arm, angle=-theta, axis=vector(0, 0, 1))

            # self.arrow.visible = False
            # if self.spring.length < self.length:
            #     self.arrow = arrow(pos = self.lever_arm, axis = norm((self.spr_const * self.lever_arm_length) * self.axis) * 100, shaftwidth = 10)
            # elif self.spring.length > self.length:
            #     self.arrow = arrow(pos = self.lever_arm, axis = norm(-1 * ((self.spr_const * self.lever_arm_length) * self.axis)) * 100, shaftwidth = 10)
        else:
            self.lever_arm = rotate(self.lever_arm, angle=-theta, axis=vector(0, 0, 1))
            self.axis = self.lever_arm - self.spring.pos
            self.spring.visible = False
            self.spring = helix(pos=vec(SPRING_LEFT_X, self.left_y_level, 0),axis=self.axis,color=color.cyan,radius=self.radius,length=(mag(self.axis)),coils=self.length / self.radius)
        #self.lever.visible = False
        #self.lever = helix(
        #         pos=vec(0, 0, 0),
        #         axis=self.lever_arm,
        #         color=color.cyan,
        #         radius=self.radius,
        #         length=(self.lever_arm_length),
        #         coils=self.length / self.radius,
        #)

    def get_angular_frequency_component(self):
        if self.spring.length < self.length:
            return cross((self.spr_const * self.lever_arm_length) * self.axis, self.lever_arm)
        elif self.spring.length > self.length:
            return cross(-1 * ((self.spr_const * self.lever_arm_length) * self.axis),self.lever_arm)
        else:
            return vec(0, 0, 0)

    def get_torque(self):
        return cross(-1 * ((self.spr_const * (self.spring.length - self.length)) * self.axis),self.lever_arm)

    # def update(self):
    # where actual simulation goes
    # pass