VillamCalc

import math
import numpy as np

# variables

M = 100
Lv = 1.5
h = 0.15
Iv = 200000
Delta_l = [0, -(Lv / M), 0]

nur = 1
nu0 = 4 * math.pi * 10 ** (-7)

K = 2
N1 = 100
N2 = 100

Ig1 = Iv / 2
Ig2 = Iv / 2


# vectors

rK1 = [0, 0, (-h)]
rK2 = [0, 0, (-h)]

rV1 = [0.26, -0.16, 0]
rV2 = [-0.26, -0.16, 0]

#

Delta_r1 = [(rV1[i] - rK1[i]) / N1 for i in range(len(rV1))]
Delta_r2 = [(rV2[j] - rK2[j]) / N2 for j in range(len(rV2))]

#print("Delta_r1 result: ", Delta_r1)
#print("Delta_r2 result: ", Delta_r2)


# calculations

vectors_rpX_j = [[0, Lv / M * (j - 0.5), (-h)] for j in range(1, M + 1)]

vectors_r1X_i = [ [rK1[j] + (i - 0.5) / N1 * (rV1[j] - rK1[j]) for j in range(len(rK1))] for i in range(1, N1 + 1) ]

vectors_r2X_i = [ [rK2[j] + (i - 0.5) / N2 * (rV2[j] - rK2[j]) for j in range(len(rK2))] for i in range(1, N2 + 1) ]

#

scalar = (nur * nu0 / (4 * math.pi) * Ig1)

Bp_res_part = [scalar * x for x in Delta_r1]

scalar_2 = (nur * nu0 / (4 * math.pi) * Ig2)

Bp_2 = [scalar_2 * x for x in Delta_r2]


#print(result_vectors)
vektor = np.array([1, 2, 3])
vektor_abs_result = np.linalg.norm(vektor)

#print("A [1, 2, 3] vektor abszolút értéke:", vektor_abs_result)

result_vectors = []

for j in vectors_rpX_j:
    for i in vectors_r1X_i:

        result_vector = [j_elem - i_elem for j_elem, i_elem in zip(j, i)]

        result_vectors.append(result_vector)


vec_abs = []

for vec in result_vectors:
    abs_value = math.sqrt(sum(x**2 for x in vec))
    vec_abs.append(abs_value)

#

abs_list = []

for j in vectors_rpX_j:
    for i in vectors_r1X_i:

        result_vector = [j_elem - i_elem for j_elem, i_elem in zip(j, i)]
        result_vectors.append(result_vector)
        abs_value_cubed = (math.sqrt(sum(x**2 for x in result_vector)))**3
        abs_list.append(abs_value_cubed)


total = []

if all(value != 0 for value in abs_list):
    for vec, abs_value_cubed in zip(result_vectors, abs_list):
        divided_vector = [element / abs_value_cubed if abs_value_cubed != 0 else 0 for element in vec]
        total.append(divided_vector)
else:
    print("Hiba: Az abs_list tartalmaz nullát, ami nem megengedett az osztás során.")


reduced = []

vector_length = len(total[0])

for i in range(0, len(total), N1):

    sum_vector = [0] * vector_length

    for vector in total[i:i + N1]:
        sum_vector = [sum(x) for x in zip(sum_vector, vector)]

    reduced.append(sum_vector)

# A scalar és a 100-as vector pakk cross product szorzata.
product_result = []

for vec in reduced:

    cross_prod = np.cross(Bp_res_part, vec)
    product_result.append(cross_prod)

#print(Delta_r1)

#vec1 = [2,5,8]
#vec2 = [10,-3,7]

#print("vektorok szorzat: ", np.cross(vec1, vec2))

result_vectors_2 = []

for j in vectors_rpX_j:
    for i in vectors_r2X_i:

        result_vector_2 = [j_elem - i_elem for j_elem, i_elem in zip(j, i)]

        result_vectors_2.append(result_vector_2)


norm_cubed_results = []

for vec in result_vectors_2:

    norm = np.linalg.norm(vec)
    norm_cubed_results.append(norm ** 3)


result2 = []

if all(value != 0 for value in norm_cubed_results):

    for vec, norm_cubed in zip(result_vectors_2, norm_cubed_results):

        divided_vector = [element / norm_cubed for element in vec]
        result2.append(divided_vector)
else:
    print("Hiba: A norm_cubed_results tartalmaz nullát, ami nem megengedett az osztás során.")


reduced_2 = []
vector_length_2 = len(result2[0])


for i in range(0, len(result2), N2):

    sum_vector = [0] * vector_length_2

    for vector in result2[i:i + N2]:
        sum_vector = [sum(x) for x in zip(sum_vector, vector)]

    reduced_2.append(sum_vector)


#print(len(total))

product_result_2 = []


for vec in reduced_2:

    cross_prod = np.cross(Bp_2, vec)
    product_result_2.append(cross_prod)


total_result = []


if len(product_result) == len(product_result_2):

    for i in range(len(product_result)):
        summed_vector = [sum(x) for x in zip(product_result[i], product_result_2[i])]

        total_result.append(summed_vector)
else:
    print("Hiba: A listák hossza nem egyezik meg.")



final_sum_vector = [0] * len(total_result[0])

for vec in total_result:

    final_sum_vector = [sum(x) for x in zip(final_sum_vector, vec)]

#print(final_sum_vector)

result_vec = [Iv * x for x in Delta_l]

#print("A skalár értékkel megszorzott vektor:", result_vec)

#most jon az ero kiszamitasa :) maybe the force with U :)

force_total = []

for v in reduced:

    cross_prod_2 = np.cross(result_vec, final_sum_vector)

    force_total.append(cross_prod_2)

#print(result_vec)
#print(len(force_total))
#print(final_sum_vector)

force = np.cross(result_vec, final_sum_vector)

print(force) #last result in vector form for calc in N