VillamCalc

import math
import numpy as np

# variables

M = 100
Lv = 1.25
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 / 3
Ig2 = 2 * (Iv / 3)


# vectors

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

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



# vectorial division

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))]




# 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)


# Az eredmény vektorok tárolására szolgáló lista inicializálása
result_vectors = []

# Végigiterálunk minden lehetséges j és i pároson
for j in vectors_rpX_j:
    for i in vectors_r1X_i:
        # Kivonjuk az i-edik vektort a j-edik vektortól
        result_vector = [j_elem - i_elem for j_elem, i_elem in zip(j, i)]
        # Hozzáadjuk az eredményt a result_vectors listához
        result_vectors.append(result_vector)

# Az eredmény kiíratása

vec_abs = []

# Iterálunk a result_vectors listán, és kiszámítjuk minden vektor abszolút értékét
for vec in result_vectors:
    abs_value = math.sqrt(sum(x**2 for x in vec))  # A vektor abszolút értékének kiszámítása
    vec_abs.append(abs_value)  # Hozzáadjuk az abszolút értéket a vec_abs listához

# Kiírjuk a vec_abs listát, hogy lássuk az abszolút értékeket

abs_list = []

for j in vectors_rpX_j:
    for i in vectors_r1X_i:
        # Kivonjuk az i-edik vektort a j-edik vektortól
        result_vector = [j_elem - i_elem for j_elem, i_elem in zip(j, i)]
        # Hozzáadjuk az eredményt a result_vectors listához
        result_vectors.append(result_vector)
        # Kiszámítjuk a vektor abszolút értékét, majd harmadik hatványra emeljük
        abs_value_cubed = (math.sqrt(sum(x**2 for x in result_vector)))**3
        # Hozzáadjuk az abszolút érték harmadik hatványát az abs_list listához
        abs_list.append(abs_value_cubed)


total = []

# Ellenőrizzük, hogy az abs_list nem tartalmaz-e nullát, hogy elkerüljük a nullával való osztást
if all(value != 0 for value in abs_list):
    for vec, abs_value_cubed in zip(result_vectors, abs_list):
        # Minden vektor elemét elosztjuk a megfelelő abszolút érték harmadik hatványával
        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])  # Feltételezve, hogy minden vektor azonos hosszúságú

# Végigiterálunk a total listán 100-as lépésközzel
for i in range(0, len(total), N1):
    # Inicializálunk egy kezdő vektort nullákkal
    sum_vector = [0] * vector_length
    # Összeadjuk az aktuális 100 vektor elemeit
    for vector in total[i:i + N1]:
        sum_vector = [sum(x) for x in zip(sum_vector, vector)]
    # Hozzáadjuk az összeget a reduced listához
    reduced.append(sum_vector)

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

# Iterálunk a reduced listán
for vec in reduced:
    # Keresztszorzat a Bp_res_part és az aktuális vektor között
    cross_prod = np.cross(Bp_res_part, vec)
    # Hozzáadjuk a keresztszorzat eredményét a product_result listához
    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 = []

# Végigiterálunk minden lehetséges j és i pároson
for j in vectors_rpX_j:
    for i in vectors_r2X_i:
        # Kivonjuk az i-edik vektort a j-edik vektortól
        result_vector_2 = [j_elem - i_elem for j_elem, i_elem in zip(j, i)]
        # Hozzáadjuk az eredményt a result_vectors listához
        result_vectors_2.append(result_vector_2)


norm_cubed_results = []

# Iterálunk a result_vectors_2 listán lévő vektorokon
for vec in result_vectors_2:
    # Kiszámítjuk a vektor normáját (abszolút értékét)
    norm = np.linalg.norm(vec)
    # A norma harmadik hatványát vesszük és hozzáadjuk az eredmények listájához
    norm_cubed_results.append(norm ** 3)


result2 = []

# Ellenőrizzük, hogy a norm_cubed_results lista nem tartalmaz-e nullát
if all(value != 0 for value in norm_cubed_results):
    # Iterálunk a result_vectors_2 listán és az azonos indexű norm_cubed_results értékeken
    for vec, norm_cubed in zip(result_vectors_2, norm_cubed_results):
        # Minden vektor elemét elosztjuk a megfelelő norma harmadik hatványával
        divided_vector = [element / norm_cubed for element in vec]
        # Hozzáadjuk az eredményt a result2 listához
        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])

# Végigiterálunk a total listán 100-as lépésközzel
for i in range(0, len(result2), N2):
    # Inicializálunk egy kezdő vektort nullákkal
    sum_vector = [0] * vector_length_2
    # Összeadjuk az aktuális N vektor elemeit
    for vector in result2[i:i + N2]:
        sum_vector = [sum(x) for x in zip(sum_vector, vector)]
    # Hozzáadjuk az összeget a reduced listához
    reduced_2.append(sum_vector)



product_result_2 = []

# Iterálunk a reduced listán
for vec in reduced_2:
    # Keresztszorzat a Bp_res_part és az aktuális vektor között
    cross_prod = np.cross(Bp_2, vec)
    # Hozzáadjuk a keresztszorzat eredményét a product_result listához
    product_result_2.append(cross_prod)



total_result = []

# Ellenőrizzük, hogy a két lista hossza megegyezik-e
if len(product_result) == len(product_result_2):
    # Iterálunk a listák hosszán
    for i in range(len(product_result)):
        # Összeadjuk a megfelelő vektorokat a két listából
        summed_vector = [sum(x) for x in zip(product_result[i], product_result_2[i])]
        # Hozzáadjuk az összeadott vektort a total_result listához
        total_result.append(summed_vector)
else:
    print("Hiba: A listák hossza nem egyezik meg.")


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

# Iterálunk a total_result listán lévő vektorokon
for vec in total_result:
    # Összeadjuk az aktuális vektort a final_sum_vector vektorral
    final_sum_vector = [sum(x) for x in zip(final_sum_vector, vec)]


result_vec = [Iv * x for x in Delta_l]


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

force_total = []

for v in reduced:
    # Keresztszorzat a Bp_res_part és az aktuális vektor között
    cross_prod_2 = np.cross(result_vec, final_sum_vector)
    # Hozzáadjuk a keresztszorzat eredményét a product_result listához
    force_total.append(cross_prod_2)


force = np.cross(result_vec, final_sum_vector)
#print(force)

# nyomatek

# elemi elmozdulas a villamharoiton X az ottani magneses ter
alma = np.cross(Delta_l, total_result)
#print(s)

#print(len(alma))

korte = np.cross(vectors_rpX_j, alma)

szilva = [sum(i) for i in zip( * korte)]
#print(szilva)

#EREDO NYOMATEK VEKTOR Momentum_Null

mumentum_null = np.multiply(Iv, szilva)
#print("nyomatek: ", mumentum_null, "Ero: ", force)

H = mumentum_null[0] / force[2]

print("Eredo ero vektor (N): ", force)

print("Az origora vett eredo forgato nyomatek vektor (Nm): ", mumentum_null)

print("Eredo ero hatasvonalanak magassaga a villamharito talpatol (meter): ", H)