def nocciolodiinerzia(listadicoordinatefinale,\
baricentrototalex,baricentrototaley,\
areatotale,matrice_inerzia_totale):
#function [noccioloordinato]=nocciolodiinerzia(listadicoordinatefinale,baricentrototalex,baricentrototaley,areatotale,matrice_inerzia_totale)
#%funzione che stabilisce quale retta è tangente alla figura e se vero, richiama la funzione che ne calcola l'antipolo
#import matplotlib.pyplot as plt
#plt.figure()
#plt.clf()
printa = 0
if printa:
print(listadicoordinatefinale)
from calcolatrice.misuras import size2, UnireMatriciRig
import numpy as np
kappa = 6
kappa2 = 2
#print(listadicoordinatefinale)
righe = size2(listadicoordinatefinale, 1)
inerzia_y = matrice_inerzia_totale[0, 0]
inerzia_xy = matrice_inerzia_totale[0, 1]
inerzia_x = matrice_inerzia_totale[0, 3]
#print(inerzia_y,inerzia_xy,inerzia_x)
ff1 = np.asmatrix(
np.zeros((size2(listadicoordinatefinale,
1), size2(listadicoordinatefinale, 2))))
listadicoordinatefinale = UnireMatriciRig(listadicoordinatefinale, ff1)
punti = 0
if printa:
print(listadicoordinatefinale)
#%%%% metodo del calcolo delle tangenti, senza il raddoppio dei confronti dei punti tra di loro
coordinatedelnocciolo = np.matrix("0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.")
#%quante rettte indica le rette uniscono due punti presi in tutte le figure
#%quanterette=(righe*(righe-1))/2
from calcolatrice.misuras import rototrasl, angolopolarecartesiano, arrotonda, minimo, massimo, UnireMatriciCol
VetRighe = range(0, righe - 1)
VetRighe1 = range(0, righe)
puntoiniziale = np.matrix("0. 0.")
puntofinale = np.matrix("0. 0.")
dex = 0.
dey = 0.
tipologia = np.matrix("0. 0. 0.")
coordxnocciolo = 0.
coordynocciolo = 0.
for i in VetRighe:
VetRighe2 = range(i + 1, righe)
for j in VetRighe2:
puntoiniziale[0, 0] = listadicoordinatefinale[i, 0]
puntoiniziale[0, 1] = listadicoordinatefinale[i, 1]
puntofinale[0, 0] = listadicoordinatefinale[j, 0]
puntofinale[0, 1] = listadicoordinatefinale[j, 1]
deltax = puntofinale[0, 0] - puntoiniziale[0, 0]
deltay = puntofinale[0, 1] - puntoiniziale[0, 1]
angolo_rad = angolopolarecartesiano(deltax, deltay)
dex = puntoiniziale[0, 0]
dey = puntoiniziale[0, 1]
for k in VetRighe1:
xdarototraslare = listadicoordinatefinale[k, 0]
ydarototraslare = listadicoordinatefinale[k, 1]
xrototraslato, yrototraslato = rototrasl(
xdarototraslare, ydarototraslare, dex, dey, angolo_rad,
"1")
ff1[k, 0] = xrototraslato
ff1[k, 1] = yrototraslato
#%si potrebbe agire qui, controllando ogni volta che il punto sia negativo o positivo,
#%si creano due variabili, una per i numeri positivi e una per i numeri negativi
#%e ogni volta che si ottiene un risultato si somma 1 a quella giusta
#%ogni volta si controlla se una è zero e l'altra no
#%se tutte e due sono diverse da zero, allora la tangente non è tale
#è un metodo meno oneroso di quello che sto usando ora?
#%listadicoordinatefinale(:,4)
#listadicoordinatefinale[:,3]=arrotonda(listadicoordinatefinale[:,3],kappa)
vettoremassimieminimi = arrotonda(ff1[:, 1], kappa)
puntominimo = minimo(vettoremassimieminimi)
puntomassimo = massimo(vettoremassimieminimi)
#####################################################################################
#print("ccc",puntominimo,puntomassimo)
cacca = np.matrix("0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.")
if printa:
print(listadicoordinatefinale)
#se passano questo if allora sono delle tangenti
ver1 = (puntomassimo >= 0 and puntominimo >= 0)
ver2 = (puntomassimo <= 0 and puntominimo <= 0)
if ver1 + ver2 == 1:
##############################
# puntoiniziale 1x2 puntofinale 1x2
if punti == 0:
coordinatedelnocciolo = np.matrix(
"0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.")
else:
coordinatedelnocciolo = UnireMatriciCol(
coordinatedelnocciolo, cacca)
coordxnocciolo = 0.
coordynocciolo = 0.
coordxnocciolo, coordynocciolo, tipologia = lunghezzedelnocciolo(
areatotale, baricentrototalex, baricentrototaley,
puntoiniziale, puntofinale, inerzia_x, inerzia_y,
inerzia_xy, kappa)
#[coordxnocciolo,coordynocciolo,tipologia]=lunghezzedelnocciolo(areatotale,baricentrototalex,baricentrototaley,puntoiniziale,puntofinale,inerzia_x,inerzia_y,inerzia_xy);
# tipologia matrice 1x3
if printa:
print(coordinatedelnocciolo)
print(type(coordinatedelnocciolo))
#####################################################################################
print(coordxnocciolo, coordynocciolo[0, 0], deltax, deltay,
baricentrototalex, baricentrototaley)
coordinatedelnocciolo[punti, 0] = coordxnocciolo[0, 0]
if printa:
print("coordynocciolo", coordynocciolo,
np.size(coordynocciolo), "ops1",
coordinatedelnocciolo[punti, 1])
print(type(coordxnocciolo), type(coordynocciolo))
if punti == 0:
coordinatedelnocciolo[punti, 1] = coordynocciolo[0, 0]
else:
coordinatedelnocciolo[punti, 1] = coordynocciolo[0, 0]
if printa:
print("ops", coordinatedelnocciolo[punti, 1])
coordinatedelnocciolo[punti, 2] = punti + 1
deltax = coordxnocciolo - baricentrototalex
deltay = coordynocciolo - baricentrototaley
theta = angolopolarecartesiano(deltax, deltay)
coordinatedelnocciolo[punti, 3] = theta
coordinatedelnocciolo[punti, 4] = puntoiniziale[0, 0]
coordinatedelnocciolo[punti, 5] = puntoiniziale[0, 1]
coordinatedelnocciolo[punti, 6] = puntofinale[0, 0]
coordinatedelnocciolo[punti, 7] = puntofinale[0, 1]
coordinatedelnocciolo[punti, 8] = tipologia[0, 0]
coordinatedelnocciolo[punti, 9] = tipologia[0, 1]
coordinatedelnocciolo[punti, 10] = tipologia[0, 2]
coordinatedelnocciolo[punti,
11] = coordxnocciolo - baricentrototalex
coordinatedelnocciolo[punti,
12] = coordynocciolo - baricentrototaley
punti = punti + 1
#print(pirla,puntominimo,puntomassimo,theta)
#a=listadicoordinatefinale[i,0]
#b=listadicoordinatefinale[i,1]
#c=listadicoordinatefinale[j,0]
#d=listadicoordinatefinale[j,1]
#print(a,b,c,d)
#%coordinatedelnocciolo(punti,5)=tipologia;
#%fprintf('%6.0f %6.0f %6.0f %6.0f \n',coordinatedelnocciolo(punti,5),coordinatedelnocciolo(punti,6),coordinatedelnocciolo(punti,7),coordinatedelnocciolo(punti,8));
#end
if printa:
print(coordinatedelnocciolo)
#end
#print(coordinatedelnocciolo.T)
#if printa:
if printa:
print(coordinatedelnocciolo.T)
coordinatedelnocciolo[:, 0] = arrotonda(coordinatedelnocciolo[:, 0], kappa)
coordinatedelnocciolo[:, 1] = arrotonda(coordinatedelnocciolo[:, 1], kappa)
#end
if printa:
print(coordinatedelnocciolo[:, 0:2])
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#%coordinatedelnocciolo sono inserite in un file di testo
#%vedere di fare una stampata di latex cos?? da segnalare in modo leggibile tutti i punti
#%plot(coordinatedelnocciolo(:,1),coordinatedelnocciolo(:,2))
#%coordinatedelnocciolo(punti,1)=coordxnocciolo;
#%coordinatedelnocciolo(punti,2)=coordynocciolo;
#%coordinatedelnocciolo=arrotondadecimali(coordinatedelnocciolo);
#%funzione che ordina le righe della matric, in base alla colonna degli angoli theta
#print(nocciolosenzadoppie.T)
#print(coordinatedelnocciolo)
#%penso che non c'è bisogno di ricavarla di nuovo, in fin dei conti la ho gia'
punti = size2(coordinatedelnocciolo, 1)
matricina = arrotonda(coordinatedelnocciolo[:, 3], kappa)
matricina.sort(axis=0)
from calcolatrice.misuras import CancDoppioni
matricina = CancDoppioni(matricina)
#noccioloordinato=np.asmatrix(np.zeros((r1,r2)))
#%codice che ordina la lista di punti in base all'angolazione antioraria a partire dall'asse x positivo
trovate = np.asmatrix(np.zeros((size2(matricina, 1), 13)))
#print(matricina)
VetPunti = range(0, punti)
VetTro = range(0, size2(matricina, 1))
#print(VetTro)
for i in VetTro:
angoloscelto = matricina[i, 0]
for j in VetPunti:
angoloj = round(coordinatedelnocciolo[j, 3], kappa)
#print(angoloscelto,angoloj)
if angoloj == angoloscelto:
trovate[i, :] = coordinatedelnocciolo[j, :]
"""
#print("kappa",size2(trovate,1),size2(trovate,2))
if size2(trovate,1)>1:
VetKappa=range(0,size2(trovate,1),size2(trovate,2))
for k in VetKappa:
noccioloordinato[i,:]=nocciolosenzadoppie[trovate[k,0],:]
else:
noccioloordinato[i,:]=nocciolosenzadoppie[trovate[0,0],:]
"""
#print(trovate)
#%metodo per cancellare i doppioni
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
return trovate
def codicesezione(self):
#%attivazione diretta del calcolatore (tutti e 3 arrivano a questo punto,
#%ma con la scelta 1 ci si arriva senza passaggi intermedi
import numpy as np
from calcolatrice.studiatore2 import studianumero1
printa = 0
#from misuras import StringaToMatrix,StringCnf
#print(type(numero0))
#ossas="<class 'str'>"
#if StringCnf(type(numero0),ossas):
#else:
# numero1=np.asmatrix(numero0)
#print(type(self))
from calcolatrice.misuras import StringCnf
prova = str(type(self))
prova2 = str("<class 'numpy.matrixlib.defmatrix.matrix'>")
#in pratica se voglio fare le prove non faccio i disegni
testare = 1
#se prove =1 allora disegno, altrimenti no
if StringCnf(prova, prova2):
numero1 = self
testare = 0
else:
numero1 = self.stringa
#if printa:
np.set_printoptions(threshold=np.nan)
if printa:
print(type(numero1))
if type(numero1) == "<class 'numpy.matrixlib.defmatrix.matrix'>":
print("il tipo di oggetto va bene")
else:
#type()==array
numero1 = np.asmatrix(numero1)
verz = numero1[0, 0]
#print("verz",verz)
if printa:
if verz == 042015.:
print("verz confermata", verz)
else:
print(
"Il codice di versione non corrisponde, il file non è valido\n"
)
kk = numero1[0, 1] #non deve essere mai minore di 2
if kk > 3 and kk < 20:
kk = 3
print("kk", kk) #standard 2
vuoifareancheilnocciolo = numero1[
0, 2] #uguale a 1 se vuoi fare, uguale a 0 se non lo vuoi fare
if vuoifareancheilnocciolo == 0 or vuoifareancheilnocciolo == 1:
if printa:
print("vuoifareancheilnocciolo", vuoifareancheilnocciolo)
else:
vuoifareancheilnocciolo = 0 #standard 0
discretizzaarchicerchi = numero1[0, 3] #standard 50
if printa:
print("discretizzaarchicerchi", discretizzaarchicerchi)
if discretizzaarchicerchi < 4 or discretizzaarchicerchi > 100:
discretizzaarchicerchi = 30
contorna = numero1[0, 4] #%standard 1
if contorna == 0. or contorna == 1.:
if printa:
print("contorna conf", contorna)
else:
contorna = 0
from calcolatrice.misuras import size2 #, EstraiUnPezzo
sollecitazione = np.asmatrix(np.zeros((1, 8)))
if size2(numero1, 2) >= 14:
sollecitazione = np.transpose(numero1[0, 5:13])
if printa:
print("numerotrasla", numero1)
numero1 = np.delete(numero1, (0), axis=0)
#numero1=np.asmatrix(EstraiUnPezzo(numero1,1,"end",0,"end"))
if printa:
print("numerotrasla", numero1)
#numero1=numero1([2:end,:]
if printa:
print("aa1")
#%questo sarebbe il programma principale di calcolo dell'inerzia
numerodifiguregeneriche = size2(numero1,
1) #% dimmi quante figure vuoi inserire
#print("numfiggen",numerodifiguregeneriche)
#%cerca di calcolare i parametri xy tali da traslare tutte le figure in un sistema di riferimento positivo
calcolo = 2
traslax = 0
traslay = 0
VetRigheGen = range(
0, numerodifiguregeneriche) #print("VetRigheGen",VetRigheGen)
if printa:
print("aa2")
for k in VetRigheGen:
#[~,~,~,~,~,~,minimox,minimoy,~,~]=studiatore2()
#print(type(np.asmatrix(numero1[k,:])))
#print("numerok",numero1[k,:],size2(numero1[k,:],1),size2(numero1[k,:],2))
riganumer = np.asmatrix(numero1[k, :])
coordinate, c1, c2, c3, c4, c5, minimox, minimoy, c8, c9 = studianumero1(
riganumer, kk, calcolo, 0, 0, 0)
traslax = np.minimum(traslax, minimox)
traslay = np.minimum(traslay, minimoy)
if printa:
print("numerotrasla", numero1)
if printa:
print("aa3")
#%per sicurezza aumenta di 2
traslax = -traslax + 2
traslay = -traslay + 2
#print("traslax",traslax)
#print("traslay",traslay)
#print("traslax",traslax)
#print("traslay",traslay)
calcolo = 3
"""
%traslax=8000; %il 20000 #porta un errore che si nota
%traslay=traslax;
#%non modificare"""
#print(VetRigheGen)
numero4 = numero1
#print(numero4.T)
for i in VetRigheGen:
#print("numero4 33", i,numero1[i,:])
numero33 = np.asmatrix(numero1[i, :])
#print(type(numero33))
b1, b2, b3, b4, b5, b6, b7, b8, numero4[i, :], b9 = studianumero1(
numero33, kk, calcolo, 0, traslax, traslay)
#[~,~,~,~,~,~,~,~,numero4,~]=studiatore2()5
#print("numero4", numero4)
from calcolatrice.xgeom2 import xgeom
#%calcolo dei parametri geometrici della sezione
#print(transponi(numero4))
if printa:
print("numero4", numero1)
areatotale, baricentrototalex, baricentrototaley, essex, essey, matrice_inerzia_totale, Aangolo_rad, Aangolo_gon, angolo_rad, Aangolo_grad, rhoeee, rhonii, casoinesame, inerziaeee, inerzianii = xgeom(
numero4, kk)
if printa:
print("cacca")
print(areatotale)
print(baricentrototalex)
print(baricentrototaley)
#print(vettore_baricentrix)
#print(vettore_baricentriy)
print(essex)
print(essey)
#print(vet_m_inerzia_huygens)
print(matrice_inerzia_totale)
print(Aangolo_rad)
print(Aangolo_gon)
print(Aangolo_grad)
print(rhoeee)
print(rhonii)
print(casoinesame)
print(inerziaeee)
print(inerzianii)
#%fprintf('#####');
#%fprintf('#####');
"""%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%metodo per scoprire la lista delle coordinate, per calcolare il massimo e il minimo"""
from calcolatrice.misuras import listare, CancDoppioni
listadicoordinatefinale = listare(numero1, kk, discretizzaarchicerchi)
#print(size2(listadicoordinatefinale,1))
#print(listadicoordinatefinale)
"""
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
"""
listadicoordinatefinale = CancDoppioni(listadicoordinatefinale)
#se c'e almeno una figura vuo5ta fai il calcolo peso
if printa:
print("casfnhedhbvsehbvsedv")
if 1:
contorna = 0
for ps in VetRigheGen:
if numero1[ps, 1] < 0:
contorna = 1 #cambialo a 1 poi
#per evidente semplicità non ho voglia di fare anche questo calcolatore
ps = numerodifiguregeneriche
if contorna:
from calcolatrice.contornalacomposizione import contorna
listadicoordinatefinale = contorna(listadicoordinatefinale,
numero1, kk,
discretizzaarchicerchi)
matrice_inerzia_totale = np.asmatrix(matrice_inerzia_totale)
#print(listadicoordinatefinale)
#print(listadicoordinatefinale)
numeri = size2(listadicoordinatefinale, 1)
VetLista = range(0, numeri)
for t in VetLista:
#print(t)
listadicoordinatefinale[t, 0] = listadicoordinatefinale[t, 0] - traslax
listadicoordinatefinale[t, 1] = listadicoordinatefinale[t, 1] - traslay
baricentrototalex = baricentrototalex - traslax
baricentrototaley = baricentrototaley - traslay
essey = areatotale * baricentrototalex
essex = areatotale * baricentrototaley
"""%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"""
if vuoifareancheilnocciolo:
"""
%visto la quantità di calcoli richiesti, lascio la possibilit di scelta??
"""
#print(listadicoordinatefinale,baricentrototalex,baricentrototaley,areatotale,matrice_inerzia_totale)
from calcolatrice.nocciolo import nocciolodiinerzia
noccioloordinato=nocciolodiinerzia(listadicoordinatefinale,\
baricentrototalex,baricentrototaley,\
areatotale,matrice_inerzia_totale)
#%nel noccioloordinato coordinate #del nocciolo ordinate in senso #antiorario a partire da x positivo
#noccioloordinato=np.matrix("0 0 0 0 0 0 0 0 0 0 0 0 0;1 1 1 1 1 1 1 1 1 1 1 1 1; 2 2 2 2 2 2 2 2 2 2 2 2 2")
else:
noccioloordinato = -1
#print(listadicoordinatefinale)
#%%%%%%%%%%%%%%%%%%%%%%%%
#print(sollecitazione)
if sollecitazione[0, 0] == 1. or sollecitazione[0, 0] == 2.:
#x.sollecitazione=sollecitazione
#vettore_baricentrix=vettore_baricentrix-traslax
#vettore_baricentriy=vettore_baricentriy-traslay
#baricentrototalex=baricentrototalex-traslax
#baricentrototaley=baricentrototaley-traslay
from calcolatrice.spinte import sollecitatore
#string=stampacalcoli()
puntopiulontanoyyy1,puntopiulontanoxxx1,puntopiulontanoyyy2,puntopiulontanoxxx2,sigmadelpuntopiulontano1,sigmadelpuntopiulontano2,tresca,mises=sollecitatore(sollecitazione,angolo_rad,Aangolo_rad,\
listadicoordinatefinale,areatotale,baricentrototalex,\
baricentrototaley,rhonii,rhoeee,inerzianii,inerziaeee)
else:
puntopiulontanoyyy1 = 0
puntopiulontanoxxx1 = 0
puntopiulontanoyyy2 = 0
puntopiulontanoxxx2 = 0
sigmadelpuntopiulontano1 = 0
sigmadelpuntopiulontano2 = 0
from calcolatrice.risultatileggibili import RisToString
#risultatitxt(x,noccioloordinato)
#areatotale,baricentrototalex,baricentrototaley,essex,essey,matrice_inerzia_totale,Aangolo_rad,Aangolo_gon,Aangolo_grad,rhoeee,rhonii,casoinesame,inerziaeee,inerzianii
stringa = RisToString(noccioloordinato, vuoifareancheilnocciolo,
areatotale, baricentrototalex, baricentrototaley,
essex, essey, matrice_inerzia_totale, Aangolo_rad,
Aangolo_gon, Aangolo_grad, rhoeee, rhonii,
casoinesame, inerziaeee, inerzianii)
#print(noccioloordinato)
#%%%%%%%%%%%%%%%%%%%%%%%%
if printa:
print("cacca")
print("areatotale", areatotale)
print("barix", baricentrototalex)
print("bariy", baricentrototaley)
#print(vettore_baricentrix)
#print(vettore_baricentriy)
print("essex", essex)
print("essey", essey)
#print(vet_m_inerzia_huygens)
print("inerzia", matrice_inerzia_totale)
print("angolo_rad", angolo_rad)
print("Aangolo_gon", Aangolo_gon)
print("Aangolo_grad", Aangolo_grad)
print("rhoeee", rhoeee)
print("rhonii", rhonii)
print("casoinesame", casoinesame)
print("inerziaeee", inerziaeee)
print("inerzianii", inerzianii)
#per disegnare
#nomArch="ciccione"
if testare:
for t in VetLista:
#print(t)
listadicoordinatefinale[t,
0] = listadicoordinatefinale[t,
0] + traslax
listadicoordinatefinale[t,
1] = listadicoordinatefinale[t,
1] + traslay
baricentrototalex = baricentrototalex + traslax
baricentrototaley = baricentrototaley + traslay
if vuoifareancheilnocciolo:
quantecoordinatenocciolo = size2(noccioloordinato, 1)
VetListaNocc = range(0, quantecoordinatenocciolo)
for t in VetListaNocc:
#print(t)
noccioloordinato[t, 0] = noccioloordinato[t, 0] + traslax
noccioloordinato[t, 1] = noccioloordinato[t, 1] + traslay
from calcolatrice.plottare import poltrire
poltrire(self,numero1,kk,discretizzaarchicerchi,vuoifareancheilnocciolo\
,noccioloordinato,listadicoordinatefinale,traslax,traslay,\
sollecitazione,baricentrototalex,baricentrototaley,Aangolo_rad,\
rhonii,rhoeee,puntopiulontanoyyy1,puntopiulontanoxxx1,\
puntopiulontanoyyy2,puntopiulontanoxxx2,sigmadelpuntopiulontano1,\
sigmadelpuntopiulontano2,angolo_rad)
if printa:
print(stringa)
#plottare(numero1,kk,nomArch,discretizzaarchicerchi,vuoifareancheilnocciolo,noccioloordinato,listadicoordinatefinale,traslax,traslay,sollecitazione,x)
return stringa
def contorna(listadicoordinatefinale,numero1,kk,discretizzaarchicerchi):
#function [contorni]=contornalacomposizione()
aa=0 #%uguale a 1 se vuoi fare un controllo all'inizio e alla fine
from math import floor, ceil
from calcolatrice.misuras import size2,minimo,massimo,DentroLaFigura,RiduciDimensioni,UnireMatriciCol
import numpy as np
if aa:
print(listadicoordinatefinale)
print(size2(listadicoordinatefinale,0))
#%listadicoordinatefinale=[[0 0 5 5 0 0 0 2 2 0];[0 5 5 0 0 0 2 2 0 0]]';
#%numerodifiguregeneriche=1;
numerodifiguregeneriche=size2(numero1,1) #% dimmi quante figure vuoi inserire
#%definisci il passo del calcolo
righe=size2(listadicoordinatefinale,1)
passo=10
Vet1=range(0,righe-1)
for i in Vet1:
Vet2=range(i+1,righe)
for j in Vet2:
distanza=((listadicoordinatefinale[i,0]-listadicoordinatefinale[j,0])**2+(listadicoordinatefinale[i,1]-listadicoordinatefinale[j,1])**2)**0.5
#print(distanza)
if distanza<passo and distanza>0:
passo=distanza
#%il numero può essere modulato liberamente tra 'passo/n' e 'passo'
inpiu=2
#%passo=0.25;
xv=listadicoordinatefinale[:,0]
yv=listadicoordinatefinale[:,1]
xmin=floor(minimo(xv))-inpiu
xmax=ceil(massimo(xv))+inpiu
ymin=floor(minimo(yv))-inpiu
ymax=ceil(massimo(yv))+inpiu
#passo=np.minimum((xmax-xmin)/passo,(ymax-ymin)/passo)*2
#print(xmin,xmax,ymin,ymax)
#%arrotonda xmin inferiormente e poi sali di un tasso fisso fino a xmax arrotondato superiormente
#%arrotonda xmin inferiormente e poi sali di un tasso fisso fino a xmax arrotondato superiormente
if aa:
print(xmin,xmax,ymin,ymax,ceil(passo))
xa=np.linspace(xmin,xmax,ceil(passo),endpoint=True)
ya=np.linspace(ymin,ymax,ceil(passo),endpoint=True)
magliacx,magliacy=np.meshgrid(xa,ya)
#print(size2(xa,1),size2(xa,2),size2(ya,1),size2(ya,2),size2(magliacx,1),size2(magliacx,2),size2(magliacy,1),size2(magliacy,2))
from calcolatrice.studiatore2 import studianumero1
VetNum=range(0,numerodifiguregeneriche)
inlocale=np.asmatrix(np.zeros((size2(magliacx,1),size2(magliacx,2))))
for i in VetNum:
calcolo=4
coordinate,b2,b3,b4,b5,b6,b7,b8,b9,peso_specifico=studianumero1(numero1[i,:],kk,calcolo,discretizzaarchicerchi,0,0)
#[coordinate,~,~,~,~,~,~,~,~,peso_specifico]=studiatore(numero1(i,:),kk,calcolo,discretizzaarchicerchi,0,0);
#%peso_specifico=1;
#%coordinate=[[0 0 5 5 0];[0 5 5 0 0]]';
if peso_specifico>0:
coordx=coordinate[:,0]
coordy=coordinate[:,1]
dentro=DentroLaFigura(coordinate,magliacx,magliacy)
inlocale=inlocale+dentro
#%inlocale=inlocale+on; noto dei problemi con i contorni,
#%capita che vengono contati due volte
for i in VetNum:
calcolo=4;
coordinate,b2,b3,b4,b5,b6,b7,b8,b9,peso_specifico=studianumero1(numero1[i,:],kk,calcolo,discretizzaarchicerchi,0,0)
#%peso_specifico=-1;
#%coordinate=[[0 0 2 2 0];[0 2 2 0 0]]';
if peso_specifico<0:
coordx=coordinate[:,0]
coordy=coordinate[:,1]
innega=DentroLaFigura(coordinate,magliacx,magliacy)
inlocale=inlocale-innega
#inlocale=inlocale-onnega; noto dei problemi con i contorni,
#capita che vengono contati due volte
#print(inlocale)
#np.savetxt("cacca.csv", inlocale, delimiter=' ', header='')
#%clf;
#%plot (coordx', coordy');
#%hold on;
magliacx,magliacy,inlocale=RiduciDimensioni(magliacx,magliacy,inlocale)
#size2(inlocale,0)
numerodicontorni=0
vetto=size2(listadicoordinatefinale,1)
VetViz1=range(0,size2(inlocale,1))
VetViz2=range(0,size2(inlocale,2))
#print(vetto,VetViz1,VetViz2)
VetK1=range(0,vetto)
#print(size2(inlocale,1),size2(inlocale,2))
vuota=np.matrix("0 0")
vai=0
for k in VetK1:
centra=0
coordx=listadicoordinatefinale[k,0]
coordy=listadicoordinatefinale[k,1]
for i in VetViz1:
for j in VetViz2:
#print(i,j)
if inlocale[i,j]>0.5:
distanza=((coordx-magliacx[i,j])**2+(coordy-magliacy[i,j])**2)**0.5
if distanza<=2*passo:
centra=1
#i=size2(inlocale,1)
#j=size2(inlocale,2)
#%plot (magliacx(i,j), magliacy(i,j), "@g");
if vai==0:
vai=vai+1
contorni=np.matrix("0 0")
if centra==1:
contorni=UnireMatriciCol(contorni,vuota)
contorni[numerodicontorni,0]=coordx
contorni[numerodicontorni,1]=coordy
numerodicontorni=numerodicontorni+1
contorni=contorni[0:numerodicontorni-1,0:2]
#%hold off;
if aa:
print(contorni)
print(size2(contorni,0))
return contorni
def disegna(self, numero1):
#print(numero1)
#print(listadicoordinatefinale)
#function poltrire(numero1,kk,nomArch,discretizzaarchicerchi,vuoifareancheilnocciolo,noccioloordinato,listadicoordinatefinale,traslax,traslay,sollecitazione,x)
kk = numero1[0, 1]
discretizzaarchicerchi = numero1[0, 3]
vuoiplottare = 1
scherza = 0
printa = 0
#%x.Aangolo_rad %quello dellasse neutro
#%x.angolo_rad %quello della solleciazione
import numpy as np
from calcolatrice.misuras import size2
numerodifiguregeneriche = size2(numero1,
1) # % dimmi quante figure vuoi inserire
VetFig = range(1, numerodifiguregeneriche)
if printa:
print(VetFig)
#%facciamo 4 grafici:
#% 1 geometria fino agli assi principali
#% 2 geometria con assi principali ed ellisse dinerzia
#% 3 geometria con assi principali e nocciolo dinerzia
#% 4 geometria con lo studio dell'asse neutro
#%clf %cancella il grafico corrente
#%alla fine uno e basta, che poi mi rompo
scalatore = self.scalatore
import matplotlib.pyplot as plt
#figsize=(11.69,8.27),dpi=600
fig = plt.figure()
#plt.clf()
#plt.rcdefaults()
if scherza:
plt.xkcd(scale=1, length=100, randomness=2, figure=fig)
coordinate = 0
from calcolatrice.studiatore2 import studianumero1
for i in VetFig:
calcolo = 5
cacca = numero1[i, :]
[coordinate, b1, b2, b3, b4, b5, b6, b7, b8,
peso_specifico] = studianumero1(cacca, kk, calcolo,
discretizzaarchicerchi, 0, 0)
if peso_specifico > 0:
#print(coordinate)
coordinate = np.dot(scalatore, coordinate)
vettore = size2(coordinate, 1)
#0print(size2(coordinate,0))
coordx = np.arange(0, vettore)
#print(coordx)
coordy = np.arange(0, vettore)
VetVettore = range(0, vettore)
for j in VetVettore:
coordx[j] = coordinate[j, 0]
coordy[j] = coordinate[j, 1]
if vuoiplottare:
if printa:
print(coordx, coordy) #plt.plot(coordx,coordy,"black")
plt.plot(coordx,
coordy,
"black",
alpha=1,
rasterized=True,
figure=fig)
plt.fill(coordx,
coordy,
"red",
alpha=0.8,
rasterized=True,
figure=fig)
figure_wgt = self.root.ids['figure_wgt'] # MatplotFigure
figure_wgt.figure = fig
#plt.fill(x,y)
#patch(coordinate(:,1)-traslax,coordinate(:,2)-traslay,"red")
for i in VetFig:
calcolo = 5
cacca = numero1[i, :]
[coordinate, b1, b2, b3, b4, b5, b6, b7, b8,
peso_specifico] = studianumero1(cacca, kk, calcolo,
discretizzaarchicerchi, 0, 0)
if peso_specifico < 0:
#print(coordinate)
coordinate = np.dot(scalatore, coordinate)
vettore = size2(coordinate, 1)
#0print(size2(coordinate,0))
coordx = np.arange(0, vettore)
#print(coordx)
coordy = np.arange(0, vettore)
VetVettore = range(0, vettore)
for j in VetVettore:
coordx[j] = coordinate[j, 0]
coordy[j] = coordinate[j, 1]
if vuoiplottare:
if printa:
print(coordx, coordy)
#plt.plot(coordx,coordy,"black")
plt.fill(coordx,
coordy,
"white",
alpha=1,
rasterized=True,
figure=fig)
plt.plot(coordx,
coordy,
"white",
alpha=1,
rasterized=True,
figure=fig)
figure_wgt = self.root.ids['figure_wgt'] # MatplotFigure
figure_wgt.figure = fig
#patch(coordinate(:,1)-traslax,coordinate(:,2)-traslay,"white")
#fig.set_size_inches([11.69,8.27])
#plt.axis('off')
#plt.grid(False)
#plt.autoscale(True)
#plt.yscale('linear')
#plt.xscale('linear')
#plt.show(fig)
if 0:
if printa:
print("beeeeeh")
fig.savefig("solooggetto.png", dpi=600)
plt.close(fig)
#os.chdir(via)
"""
%text(assebaricentrototalex(2)-0.5,assebaricentrototaley(2),'Xo');
%text(assebaricentrototalex(5),assebaricentrototaley(5),'Yo');
"""
return 1
def sollecitatore(sollecitazione, angolo_rad, Aangolo_rad,
listadicoordinatefinale, areatotale, baricentrototalex,
baricentrototaley, rhonii, rhoeee, inerzianii, inerziaeee):
#function [x]=elaborazione_della_sollecitazione(x)
#%attenzione la parte di elaboratore non capisce se una figura è stata eliminata,
#%quindi ci possono essere grossi problemi nel calcolo del punto più lontano
#%se ci sono vuoti
#%l'applivazione e stata aggiornata e ora puo calcolare efficacemente i vuoti
#%ragion per cui la funzione e stata riaggiunta alla alpha
#%c'è
#%flessione deviata
#%pressoflessione deviata
#%cd risultati
#%completo=csvread('datidellefiguracompleta.csv');
#%cd ..
import numpy as np
from math import pi, cos, sin
from calcolatrice.misuras import size2, UnireMatriciRig, angolopolarecartesiano
moltiplica = 1
angolo_rad = 0
ricorda = Aangolo_rad
ff1 = np.asmatrix(np.zeros((size2(listadicoordinatefinale, 1), 2)))
listadicoordinatefinale = UnireMatriciRig(listadicoordinatefinale, ff1)
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#%tipo forza (1) o tipo momento (2)
tipo = sollecitazione[0, 0]
punto_x_di_applicazione = sollecitazione[1, 0]
punto_y_di_applicazione = sollecitazione[2, 0]
trazioneocompressione = sollecitazione[3, 0]
sforzonormale = sollecitazione[4, 0]
momento = sollecitazione[5, 0]
direzionedelmomento = sollecitazione[6, 0]
tau = sollecitazione[7, 0]
#sigmamassimadiprogetto=sollecitazione[0,8]
direzionedelmomento = direzionedelmomento / 180 * pi
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#%funzione di rototraslazione del punto di applicazione
#%c'e un errore nella funzione sotto!!!!!!!!!!!!!!!!!!!!!!!
#%%%%%%%%%%%%%%%%%%%
#%cd risultati
#%listadicoordinatefinale=csvread('listadicoordinatefinale.csv');
#%cd ..
#%vettore delle y
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#%listadicoordinatefinale
quantecoordinate = size2(listadicoordinatefinale,
1) #% dimmi quante figure vuoi inserire
#=grandezza(1,1);
punto_eee_di_applicazione = 0
punto_nii_di_applicazione = 0
dex = 0
dey = 0
angolo_rad = ricorda
VetQ = range(0, quantecoordinate)
from calcolatrice.misuras import rototrasl
for i in VetQ:
xdarototraslare = listadicoordinatefinale[i, 0] - baricentrototalex
ydarototraslare = listadicoordinatefinale[i, 1] - baricentrototaley
#%angolo_rad già dichiarato
xrototraslato, yrototraslato = rototrasl(xdarototraslare,
ydarototraslare, dex, dey,
angolo_rad, moltiplica)
listadicoordinatefinale[i, 2] = xrototraslato
listadicoordinatefinale[i, 3] = yrototraslato
momentonii = 0
momentoeee = 0
sigmamassima = 0
termine1 = 0
termine2 = 0
termine3 = 0
termine4 = 0
termine5 = 0
attata = 0
m = 0
quella = 0
sigmadelpuntopiulontano1 = 0
sigmadelpuntopiulontano2 = 0
if tipo == 1:
#%rototraslazione sugli assi principali del punto di applicazione
xdarototraslare = punto_x_di_applicazione - baricentrototalex
ydarototraslare = punto_y_di_applicazione - baricentrototaley
angolo_rad = ricorda
xrototraslato, yrototraslato = rototrasl(xdarototraslare,
ydarototraslare, dex, dey,
angolo_rad, moltiplica)
punto_eee_di_applicazione = xrototraslato
punto_nii_di_applicazione = yrototraslato
m = -(punto_eee_di_applicazione *
(rhoeee)) / ((rhonii) * punto_nii_di_applicazione)
quella = -(rhoeee) / punto_nii_di_applicazione
deltax = 2 - 1
deltay = (m * 2 + quella) - (m * 1 + quella)
[theta] = angolopolarecartesiano(deltax, deltay)
rettadelnullo = theta
angolo_rad = rettadelnullo
listadicoordinatefinale = UnireMatriciRig(listadicoordinatefinale, ff1)
listadicoordinatefinale[:, 4] = listadicoordinatefinale[:, 2]
listadicoordinatefinale[:, 5] = listadicoordinatefinale[:, 3]
#%x.listadicoordinatefinale
for i in VetQ:
xdarototraslare = listadicoordinatefinale[i, 2]
ydarototraslare = listadicoordinatefinale[i, 3] - quella
xrototraslato, yrototraslato = rototrasl(xdarototraslare,
ydarototraslare, dex, dey,
angolo_rad, moltiplica)
listadicoordinatefinale[i, 4] = xrototraslato
listadicoordinatefinale[i, 5] = yrototraslato
elif tipo == 2:
attata = direzionedelmomento - ricorda
momentoeee = momento * cos(attata)
momentonii = momento * sin(attata)
m = (momentonii * inerziaeee / momentoeee / inerzianii)
quella = 0
deltax = 1
deltay = m
theta = angolopolarecartesiano(deltax, deltay)
rettadelnullo = theta
angolo_rad = rettadelnullo
dex = 0
dey = 0
listadicoordinatefinale = UnireMatriciRig(listadicoordinatefinale, ff1)
for i in VetQ:
xdarototraslare = listadicoordinatefinale[i, 2]
ydarototraslare = listadicoordinatefinale[i, 3]
xrototraslato, yrototraslato = rototrasl(xdarototraslare,
ydarototraslare, dex, dey,
angolo_rad, moltiplica)
listadicoordinatefinale[i, 4] = xrototraslato
listadicoordinatefinale[i, 5] = yrototraslato
else:
print('ma che altri problemi?')
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
massimodellenii = listadicoordinatefinale[0, 5]
posizionedelmassimodellenii = 1
for i in VetQ: #2:quantecoordinate
if listadicoordinatefinale[i, 5] > massimodellenii:
massimodellenii = listadicoordinatefinale[i, 5]
posizionedelmassimodellenii = i
puntopiulontanoeee1 = listadicoordinatefinale[posizionedelmassimodellenii,
2]
puntopiulontanonii1 = listadicoordinatefinale[posizionedelmassimodellenii,
3]
puntopiulontanoxxx1 = listadicoordinatefinale[posizionedelmassimodellenii,
0]
puntopiulontanoyyy1 = listadicoordinatefinale[posizionedelmassimodellenii,
1]
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
minimodellenii = listadicoordinatefinale[0, 5]
posizionedelminimodellenii = 1
for i in VetQ: #=2:quantecoordinate
if listadicoordinatefinale[i, 5] < minimodellenii:
minimodellenii = listadicoordinatefinale[i, 5]
posizionedelminimodellenii = i
puntopiulontanoeee2 = listadicoordinatefinale[posizionedelminimodellenii,
2]
puntopiulontanonii2 = listadicoordinatefinale[posizionedelminimodellenii,
3]
puntopiulontanoxxx2 = listadicoordinatefinale[posizionedelminimodellenii,
0]
puntopiulontanoyyy2 = listadicoordinatefinale[posizionedelminimodellenii,
1]
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
if tipo == 1:
termine1 = (trazioneocompressione * sforzonormale) / areatotale
termine2 = punto_nii_di_applicazione * puntopiulontanonii1 / (rhoeee)
termine3 = punto_eee_di_applicazione * puntopiulontanoeee1 / (rhonii)
termine4 = punto_nii_di_applicazione * puntopiulontanonii2 / (rhoeee)
termine5 = punto_eee_di_applicazione * puntopiulontanoeee2 / (rhonii)
sigmadelpuntopiulontano1 = termine1 * (1 + termine2 + termine3)
sigmadelpuntopiulontano2 = termine1 * (1 + termine4 + termine5)
sigmamassima = sigmadelpuntopiulontano1
if sigmamassima > sigmadelpuntopiulontano2:
sigmamassima = sigmadelpuntopiulontano2
elif tipo == 2:
#%funzione che richiama il calcolo del momento
#x.termine1=0;
#%fprintf('momentoeee')
termine2 = momentoeee / inerziaeee * puntopiulontanonii1
termine3 = momentonii / inerzianii * puntopiulontanoeee1
termine4 = momentoeee / inerziaeee * puntopiulontanonii2
termine5 = momentonii / inerzianii * puntopiulontanoeee2
sigmadelpuntopiulontano1 = termine1 + termine2 - termine3
sigmadelpuntopiulontano2 = termine1 + termine4 - termine5
sigmamassima = np.abs(sigmadelpuntopiulontano1)
if np.abs(sigmadelpuntopiulontano2) > sigmamassima:
sigmamassima = np.abs(sigmadelpuntopiulontano2)
tresca1 = ((sigmadelpuntopiulontano1**2) + 4 * (tau**2))**0.5
mises1 = ((sigmadelpuntopiulontano1**2) + 3 * (tau**2))**0.5
tresca2 = ((sigmadelpuntopiulontano2**2) + 4 * (tau**2))**0.5
mises2 = ((sigmadelpuntopiulontano2**2) + 3 * (tau**2))**0.5
tresca = np.matrix(tresca1, tresca2)
mises = np.matrix("0 0")
tresca = np.matrix("0 0")
mises[0, 0] = mises1
mises[0, 1] = mises2
tresca[0, 0] = tresca1
tresca[0, 1] = tresca2
#%if sigmamassimadiprogetto>max(tresca,mises)
#%fprintf('quella sezione resiste \n');
#%elseif sigmamassimadiprogetto<max(tresca,mises)
#%fprintf('quella sezione non resiste \n');
#%end
#%ricorda_gon=ricorda*200/pi;
#%rettadelnullo_gon=rettadelnullo*200/pi;
#%kappa=4;
#%for i=1:11
#% for j=1:4
#% stampa(i,j)=arrotondadecimali(kappa,stampa(i,j));
#% end
#%end
#%cd risultati
#%csvwrite('produzionesollecitazione.csv',stampa,0,0);
#%csvwrite('ristampasollecitazione.csv',sollecitazione,0,0);
#%cd ..
#%disp('complimenti hai finito un intero programma!!!!!')
#end
return puntopiulontanoyyy1, puntopiulontanoxxx1, puntopiulontanoyyy2, puntopiulontanoxxx2, sigmadelpuntopiulontano1, sigmadelpuntopiulontano2, tresca, mises
def RisToString(noccioloordinato,vuoifareancheilnocciolo,areatotale,baricentrototalex,\
baricentrototaley,essex,essey,matrice_inerzia_totale,\
Aangolo_rad,Aangolo_gon,Aangolo_grad,rhoeee,rhonii,\
casoinesame,inerziaeee,inerzianii):
##%stampatore dei parametri importanti, tramite print in un file di testo txt formattato
import numpy as np
from calcolatrice.misuras import size2
"""
areatotale=4253.5234
baricentrototalex=20.58168
baricentrototaley=42.056468
essex=245.0548
essey=846.1561
matrice_inerzia_totale=np.matrix("0 0 0 0")
matrice_inerzia_totale[0,0]=5284.54846
matrice_inerzia_totale[0,1]=5114411.54846
matrice_inerzia_totale[0,2]=414.54846
matrice_inerzia_totale[0,3]=5165.54846
Aangolo_rad=1.5168
Aangolo_gon=1.51181
Aangolo_grad=0.216818
rhoeee=5.4243333
rhonii=4.33333
casoinesame=19
inerziaeee=15.2168
inerzianii=48.2286
#%h=find(nomArch==".");
#%nomTxt=nomArch;
#%nomTxt(1,h+1:h+3)="txt";
#%init="risultati\\";
#%nomTxt=[init,nomTxt];
#%aa=fopen(nomTxt,"wt");
#aa=fopen("risultati\leggifacile.txt","wt")
#triple quote per tutti
"""
#import string as str
stringa = ""
#stringa=stringa+"""Codice di calcolo dei parametri geometrici di una sezione piana.\n"""
#title("My name is %s and weight is %d kg!" % ('Zara', 21) )
#è un numero?
"""
print(str.isnumeric(stringa))
#quanti caratteri ci sono?
print(str.count(stringa,0,len(stringa)))
#cerca un oggetto dentro un altro oggetto
#una stringa dentro un'altra stringa
str1="aaacddderrr"
str2="rr"
print(str1.find(str2,0,len(str1)))
"""
stringa = stringa + """A=%6.3f \n""" % areatotale
stringa = stringa + """MSY=%6.3f\n""" % essey
stringa = stringa + """MSX=%6.3f\n""" % essex
stringa = stringa + """Xg=%6.3f\n""" % baricentrototalex
stringa = stringa + """Yg=%6.3f\n""" % baricentrototaley
stringa = stringa + """Ixg=%6.3f\n""" % matrice_inerzia_totale[0, 3]
stringa = stringa + """Iyg=%6.3f\n""" % matrice_inerzia_totale[0, 0]
stringa = stringa + """Ixgyg=%6.3f\n""" % matrice_inerzia_totale[0, 1]
stringa = stringa + """Theta=%6.3f /360\n""" % Aangolo_grad
#stringa=stringa+"""Assi Principali di Inerzia \n"""
if casoinesame == 11:
stringa = stringa + """Inii=%6.3f\n""" % inerziaeee
stringa = stringa + """Ieee=%6.3f\n""" % inerzianii
elif casoinesame == 15:
stringa = stringa + """Inii=%6.3f\n""" % inerziaeee
stringa = stringa + """Ieee=%6.3f\n""" % inerzianii
elif casoinesame == 19:
stringa = stringa + """Inii=%6.3f\n""" % inerziaeee
stringa = stringa + """Ieee=%6.3f\n""" % inerzianii
stringa = stringa + """rho2 eee=%6.3f\n""" % rhoeee
stringa = stringa + """rho2 nii=%6.3f\n""" % rhonii
stringa = stringa + """rho eee=%6.3f\n""" % rhoeee**0.5
stringa = stringa + """rho nii=%6.3f\n""" % rhonii**0.5
if vuoifareancheilnocciolo:
onlyeq = 1
numtangenti = size2(noccioloordinato, 1)
VetN = range(0, numtangenti)
#print(noccioloordinato.T)
stringa = stringa + """\n"""
if onlyeq == 0:
stringa = stringa + """Rette tangenti, Coordinate Totali e Baricentriche degli antipoli %g:\n""" % numtangenti
else:
stringa = stringa + """Tang %g:\n""" % numtangenti
if numtangenti > 10:
verbose_mode_tangenti = 0
else:
verbose_mode_tangenti = 1
if verbose_mode_tangenti == 1:
if onlyeq == 0:
stringa = stringa + """X Baric\t\t Y Baric\t\tX Totale\t Y Totale\t\teq. rette tangenti\n"""
for punti in VetN:
#print(punti,noccioloordinato[punti,11],noccioloordinato[punti,12])
stringa = stringa + """x=%6.2f \t""" % noccioloordinato[
punti, 11]
stringa = stringa + """y=%6.2f \t\t""" % noccioloordinato[
punti, 12]
stringa = stringa + """x=%6.2f \t""" % noccioloordinato[
punti, 0]
stringa = stringa + """ y=%6.2f \t\t""" % noccioloordinato[
punti, 1]
if noccioloordinato[punti, 8] == 1:
stringa = stringa + """x=%6.3f""" % noccioloordinato[
punti, 9]
elif noccioloordinato[punti, 8] == 2:
stringa = stringa + """y=%6.3f""" % noccioloordinato[
punti, 9]
elif noccioloordinato[punti, 8] == 3:
stringa = stringa + """(%6.3f)x""" % noccioloordinato[
punti, 8]
stringa = stringa + """+(%6.3f)y""" % noccioloordinato[
punti, 9]
stringa = stringa + """+(%6.3f)=0""" % noccioloordinato[
punti, 10]
stringa = stringa + """\n"""
else:
for punti in VetN:
if noccioloordinato[punti, 8] == 1.:
stringa = stringa + """x=%6.3f""" % noccioloordinato[
punti, 9]
stringa = stringa + """\n"""
elif noccioloordinato[punti, 8] == 2.:
stringa = stringa + """y=%6.3f""" % noccioloordinato[
punti, 9]
stringa = stringa + """\n"""
else: #if noccioloordinato[punti,8]==3.:
stringa = stringa + """(%6.1f)x""" % noccioloordinato[
punti, 8]
stringa = stringa + """+(%6.1f)y""" % noccioloordinato[
punti, 9]
stringa = stringa + """+(%6.1f)=0""" % noccioloordinato[
punti, 10]
stringa = stringa + """\n"""
else:
stringa = stringa + """il nocciolo viene solo disegnato\n"""
stringa = stringa + """Un progetto di Biancardi Francesco Gennaio2017\n"""
#stringa=stringa+"""https://www.facebook.com/francescoscodesection\n"""
return stringa
def studianumero1(numero1, kk, calcolo, discretizzaarchicerchi, traslax,
traslay):
from calcolatrice.misuras import size2, transponi, UnireMatriciRig, UnireMatriciCol, EstraiUnPezzo, ScalarXMatr
#print("numero1 333", numero1)
#print(size2(numero1,1))
#print(size2(numero1,2))
printa = 0
enne = 6
#il numero 1 è per: calcolare la geometria delle aree
#il numero 2 è per: calcolare i minimi
#il numero 3 è per: traslare tutto
#il numero 4 è per: i contorni
#il numero 5 è per: disegnare
from math import floor, pi, cos, sin
kk = floor(kk)
import numpy as np
coordinate = np.matrix("0 0")
baricentrox = 0
baricentroy = 0
area = 0
momenti_statici = np.matrix("0 0")
matrice_inerzia = np.matrix("0 0; 0 0")
centroix = 0
centroiy = 0
peso_specifico = 0
#siamo nel python quindi non è più i=1 ma i=0
i = 0
#print("ddasdas",numero1)
peso_specifico = numero1[0, 1]
if numero1[i, 0] == 1.:
if printa:
print(numero1)
#%studio della riga del csv
#%per il cerchio
#%circle (X Center,Y Center,Radius)
coordxc = numero1[i, kk + 0]
coordyc = numero1[i, kk + 1]
raggio = numero1[i, kk + 2]
if calcolo == 1:
area = pi * (raggio**2)
momenti_statici = np.matrix("0 0")
baricentrox = coordxc
baricentroy = coordyc
centroix = coordxc
centroiy = coordyc
inerz = pi * (raggio**4) * 0.25
matrice_inerzia = np.matrix(np.zeros((2, 2)))
matrice_inerzia[0, 0] = matrice_inerzia[1, 1] = inerz
elif calcolo == 2:
centroix = numero1[i, kk + 0] - raggio
centroiy = numero1[i, kk + 1] - raggio
elif calcolo == 3:
numero1[i, kk + 0] = numero1[i, kk + 0] + traslax
numero1[i, kk + 1] = numero1[i, kk + 1] + traslay
elif calcolo == 4 or calcolo == 5:
if calcolo == 4:
discretizzaarchicerchi = floor(discretizzaarchicerchi / enne)
#ago=np.linspace(0,2*pi,discretizzaarchicerchi+1)
#%angoloi=0; angolof=2*pi;
ago = np.asmatrix(
np.linspace(0, 2 * pi, discretizzaarchicerchi + 1))
c = transponi(
np.asmatrix(np.add(coordxc, ScalarXMatr(raggio, np.cos(ago)))))
d = transponi(
np.asmatrix(np.add(coordyc, ScalarXMatr(raggio, np.sin(ago)))))
discretizzaarchicerchi = floor(discretizzaarchicerchi)
coordinate = UnireMatriciRig(c, d)
#print(coordinate)
#print(numero1)
#%arco di cerchio
#%arc (X Center,Y Center,Radius,Start angle,End angle)
elif numero1[i, 0] == 2.:
coordxc = numero1[i, kk + 0]
coordyc = numero1[i, kk + 1]
raggio = numero1[i, kk + 2]
angoloi = numero1[i, kk + 3]
angolof = numero1[i, kk + 4]
#print("ciccione",calcolo,coordxc,coordyc,raggio,angoloi,angolof)
if calcolo == 1:
from calcolatrice.inerziasettorecoronacircolare import InerSettCoronCir
baricentrox, baricentroy, area, momenti_statici, matrice_inerzia = InerSettCoronCir(
raggio, angolof, angoloi, coordxc, coordyc)
centroix = baricentrox
centroiy = baricentroy
#print(baricentrox,baricentroy,area,momenti_statici,matrice_inerzia)
elif calcolo == 2:
centroix = numero1[i, kk + 0] - raggio
centroiy = numero1[i, kk + 1] - raggio
elif calcolo == 3:
#print("aaa")
numero1[i, kk + 0] = numero1[i, kk + 0] + traslax
numero1[i, kk + 1] = numero1[i, kk + 1] + traslay
elif calcolo == 4 or calcolo == 5:
if calcolo == 4:
discretizzaarchicerchi = floor(discretizzaarchicerchi / enne)
discretoarco = floor(1 + discretizzaarchicerchi *
np.abs(angolof - angoloi) / (2 * pi))
ago = np.asmatrix(np.linspace(angoloi, angolof, discretoarco + 1))
c = transponi(
np.asmatrix(np.add(coordxc, ScalarXMatr(raggio, np.cos(ago)))))
d = transponi(
np.asmatrix(np.add(coordyc, ScalarXMatr(raggio, np.sin(ago)))))
discretoarco = floor(discretoarco)
VetColonGen = range(1, discretoarco + 1)
c1 = np.matrix(coordxc)
c2 = np.matrix(coordyc)
d1 = UnireMatriciCol(c1, c)
d2 = UnireMatriciCol(c2, d)
coordinatex = UnireMatriciCol(d1, c1)
coordinatey = UnireMatriciCol(d2, c2)
coordinate = UnireMatriciRig(coordinatex, coordinatey)
#print("cc",coordinate)
elif numero1[i, 0] == 2.5:
#print("evviva")
coordx1 = numero1[i, kk + 0]
coordy1 = numero1[i, kk + 1]
coordx2 = numero1[i, kk + 2]
coordy2 = numero1[i, kk + 3]
spessore = numero1[i, kk + 4]
if calcolo == 1:
lunghezza = ((coordx1 - coordx2)**2 + (coordy1 - coordy2)**2)**0.5
area = spessore * lunghezza
baricentrox = (coordx1 + coordx2) / 2
baricentroy = (coordy1 + coordy2) / 2
centroix = baricentrox
centroiy = baricentroy
momentostatx = area * baricentroy
momentostaty = area * baricentrox
momenti_statici = np.asmatrix(np.zeros((1, 2)))
momenti_statici[0, 0] = momentostatx
momenti_statici[0, 1] = momentostaty
from math import atan2
angolo = atan2(coordy1 - coordy2, coordx1 - coordx2)
inerziax = spessore * (lunghezza**3) / 12 * (sin(angolo))**2
inerziay = spessore * (lunghezza**3) / 12 * (cos(angolo))**2
inerziaxy = spessore * (lunghezza**
3) * cos(angolo) * cos(angolo) / 12
matrice_inerzia = np.asmatrix(np.zeros((2, 2)))
matrice_inerzia[0, 0] = inerziay
matrice_inerzia[0, 1] = inerziaxy
matrice_inerzia[1, 0] = matrice_inerzia[0, 1]
matrice_inerzia[1, 1] = inerziax
#print(lunghezza,area,baricentrox,baricentroy,momenti_statici,matrice_inerzia)
elif calcolo == 2:
centroix = np.minimum(numero1[i, kk + 0], numero1[i, kk + 0])
centroiy = np.minimum(numero1[i, kk + 1], numero1[i, kk + 1])
elif calcolo == 3:
numero1[i, kk + 0] = numero1[i, kk + 0] + traslax
numero1[i, kk + 1] = numero1[i, kk + 1] + traslay
numero1[i, kk + 2] = numero1[i, kk + 2] + traslax
numero1[i, kk + 3] = numero1[i, kk + 3] + traslay
#print(numero1)
elif calcolo == 4:
coordinate = np.asmatrix(np.zeros((2, 2)))
coordinate[0, 0] = coordx1
coordinate[0, 1] = coordy1
coordinate[1, 0] = coordx2
coordinate[1, 1] = coordy2
#print(coordinate)
elif calcolo == 5:
s = spessore
if coordy1 - coordy2 == 0:
coordinate = np.asmatrix(np.zeros((5, 2)))
coordinate[0, 0] = coordx1
coordinate[1, 0] = coordx1
coordinate[2, 0] = coordx2
coordinate[3, 0] = coordx2
coordinate[4, 0] = coordx1
coordinate[0, 1] = coordy1 - s / 2
coordinate[1, 1] = coordy1 + s / 2
coordinate[2, 1] = coordy2 + s / 2
coordinate[3, 1] = coordy2 - s / 2
coordinate[4, 1] = coordy1 - s / 2
elif coordx1 - coordx2 == 0:
coordinate = np.asmatrix(np.zeros((5, 2)))
coordinate[0, 0] = coordx1 - s / 2
coordinate[1, 0] = coordx1 + s / 2
coordinate[2, 0] = coordx2 + s / 2
coordinate[3, 0] = coordx2 - s / 2
coordinate[4, 0] = coordx1 - s / 2
coordinate[0, 1] = coordy1
coordinate[1, 1] = coordy1
coordinate[2, 1] = coordy2
coordinate[3, 1] = coordy2
coordinate[4, 1] = coordy1
#print(coordinate)
elif numero1[i, 0] >= 3.:
#print("bravissimo")
#print("numero1 5",numero1)
punti = floor(numero1[i, 0])
#print("numero1",numero1)
#print(punti)
#%dovremmo guardare la polilinea nel senso opposto
# from misuras import EstraiUnPezzo
#numero2=numero1(1,kk+1:kk+((punti)*2))
#numero2=EstraiUnPezzo(numero1,0,0,kk+1-1,kk-1+(punti)*2)
pizza2 = size2(numero1, 2) + 2
pizza = np.asmatrix(np.zeros((1, pizza2)))
#print("pizza",pizza)
#zeros((1,))
#print(numero1)
if printa:
print(np.size(numero1), kk, punti)
pizza = np.asmatrix(numero1[:, kk:kk + (punti) * 2])
#pizza=np.asmatrix(EstraiUnPezzo(numero1,0,"end",kk,kk+(punti)*2))
pizzavecchia = np.asmatrix(EstraiUnPezzo(numero1, 0, "end", 0, kk))
#print("pv",size2(pizzavecchia,1),size2(pizzavecchia,2))
#print(pizza)
g = np.asmatrix("0 0")
g[0, 0] = pizza[0, 0]
g[0, 1] = pizza[0, 1]
numero2 = UnireMatriciRig(pizza, g)
#print("pizza dopo", numero2)
VetColonGen = range(0, punti)
#print(VetColonGen)
#print("numero22",numero2)
if calcolo == 1:
area = 0
inerziax = 0
inerziay = 0
inerziaxy = 0
momentostatx = 0
momentostaty = 0
for k in VetColonGen:
xi = numero2[i, 2 * k + 0]
yi = numero2[i, 2 * k + 1]
xip1 = numero2[i, 2 * k + 2]
yip1 = numero2[i, 2 * k + 3]
#print("pip", k, 2*k,2*k+1,2*k+2,2*k+3)
#print("pip", k, xi,yi,xip1,yip1)
#print(xi,yi,xip1,yip1)
if xip1 - xi == 0.:
m = 99999999999
else:
m = (yip1 - yi) / (xip1 - xi)
q = yi - m * xi
area = area + (xip1**2 - xi**2) * (m / 2) + q * (xip1 - xi)
momentostatx = momentostatx + (xip1**3 - xi**3) * (
(m**2) / 6) + (xip1**2 - xi**2) * (q * m / 2) + (
xip1 - xi) * ((q**2) / 2)
momentostaty = momentostaty + (xip1**3 - xi**3) * (m / 3) + (
xip1**2 - xi**2) * (q / 2)
inerziax = inerziax + (xip1**4 - xi**4) * (
(m**3) / 12) + (xip1**3 - xi**3) * (
(q * m**2) / 3) + (xip1**2 - xi**2) * (
(q**2) * m / 2) + (xip1 - xi) * ((q**3) / 3)
inerziay = inerziay + (xip1**4 - xi**4) * (m / 4) + (
xip1**3 - xi**3) * (q / 3)
inerziaxy = inerziaxy + (xip1**4 - xi**4) * ((m**2) / 8) + (
xip1**3 - xi**3) * (q * m / 3) + (xip1**2 - xi**2) * (
(q**2) / 4)
#print("area",area,"barix",baricentrox,"bariy",baricentroy)
if area < 0:
area = -area
momentostatx = -(momentostatx)
momentostaty = -(momentostaty)
inerziax = -(inerziax)
inerziay = -(inerziay)
inerziaxy = -(inerziaxy)
baricentrox = momentostaty / area
baricentroy = momentostatx / area
centroix = baricentrox
centroiy = baricentroy
momenti_statici = np.zeros((1, 2))
momenti_statici[0, 0] = momentostatx
momenti_statici[0, 1] = momentostaty
matrice_inerzia = np.zeros((2, 2))
matrice_inerzia[0, 0] = inerziay - area * (baricentrox**2)
matrice_inerzia[0,
1] = inerziaxy - area * (baricentrox * baricentroy)
matrice_inerzia[1, 0] = matrice_inerzia[0, 1]
matrice_inerzia[1, 1] = inerziax - area * (baricentroy**2)
elif calcolo == 2:
centroix = numero2[i, 0]
centroiy = numero2[i, 1]
#print(centroix,centroiy)
for k in VetColonGen:
#print(numero2[i,2*k],numero2[i,2*k+1],centroix,centroiy)
centroix = np.minimum(numero2[i, 2 * k + 0], centroix)
centroiy = np.minimum(numero2[i, 2 * k + 1], centroiy)
elif calcolo == 3:
#print(numero2)
for k in VetColonGen:
#print("bee",i,kk+2*k+1-1+1,kk+2*k+1-1+2)
numero2[i, 2 * k + 0] = numero2[i, 2 * k + 0] + traslax
numero2[i, 2 * k + 1] = numero2[i, 2 * k + 1] + traslay
pizzafinale = np.matrix(
np.zeros((1, size2(numero1, 2) - kk - 2 * k - 2)))
numero1 = UnireMatriciRig(pizzavecchia, numero2[:, 0:-2])
numero1 = UnireMatriciRig(numero1, pizzafinale)
#print(numero1)
elif calcolo == 4 or calcolo == 5:
#print(numero2)
coordinate = np.asmatrix(np.zeros((punti + 1, 2)))
#print(coordinate)
#print("ad",numero2)
#print(coordinate,VetColonGen,numero2)
for k in VetColonGen:
coordinate[k, 0] = numero2[i, 2 * k + 0]
coordinate[k, 1] = numero2[i, 2 * k + 1]
coordinate[k + 1, 0] = numero2[i, 0]
coordinate[k + 1, 1] = numero2[i, 1]
#print(coordinate)
#print(coordinate)
"""
print("nbaricentri")
print(coordinate)
print(baricentrox)
print(baricentroy)
print(area)
print(momenti_statici)
print(matrice_inerzia)
print(centroix)
print(centroiy)
print(numero1)
print(peso_specifico)
"""
coordinate = np.asmatrix(coordinate)
return coordinate, baricentrox, baricentroy, area, momenti_statici, matrice_inerzia, centroix, centroiy, numero1, peso_specifico
def poltrire(self,numero1,kk,discretizzaarchicerchi,vuoifareancheilnocciolo\
,noccioloordinato,listadicoordinatefinale,traslax,traslay,\
sollecitazione,baricentrototalex,baricentrototaley,Aangolo_rad,\
rhonii,rhoeee,puntopiulontanoyyy1,puntopiulontanoxxx1,\
puntopiulontanoyyy2,puntopiulontanoxxx2,sigmadelpuntopiulontano1,\
sigmadelpuntopiulontano2,angolo_rad):
#print(numero1)
#print(listadicoordinatefinale)
#function poltrire(numero1,kk,nomArch,discretizzaarchicerchi,vuoifareancheilnocciolo,noccioloordinato,listadicoordinatefinale,traslax,traslay,sollecitazione,x)
vuoiplottare = 1
scherza = 0
printa = 0
#%x.Aangolo_rad %quello dellasse neutro
#%x.angolo_rad %quello della solleciazione
import numpy as np
from math import pi, cos, sin
from calcolatrice.misuras import size2, minimo, massimo
numerodifiguregeneriche = size2(numero1,
1) # % dimmi quante figure vuoi inserire
VetFig = range(0, numerodifiguregeneriche)
if printa:
print(VetFig)
#%facciamo 4 grafici:
#% 1 geometria fino agli assi principali
#% 2 geometria con assi principali ed ellisse dinerzia
#% 3 geometria con assi principali e nocciolo dinerzia
#% 4 geometria con lo studio dell'asse neutro
#%clf %cancella il grafico corrente
#%alla fine uno e basta, che poi mi rompo
scalatore = self.scalatore
if scalatore != 1:
traslax = scalatore * traslax
traslay = scalatore * traslay
listadicoordinatefinale = np.dot(scalatore, listadicoordinatefinale)
baricentrototalex = scalatore * baricentrototalex
baricentrototaley = scalatore * baricentrototaley
puntopiulontanoyyy1 = puntopiulontanoyyy1 #*scalatore
puntopiulontanoxxx1 = puntopiulontanoxxx1 #*scalatore
puntopiulontanoyyy2 = puntopiulontanoyyy2 #*scalatore
puntopiulontanoxxx2 = puntopiulontanoxxx2 #*scalatore
sigmadelpuntopiulontano1 = sigmadelpuntopiulontano1 * scalatore
sigmadelpuntopiulontano2 = sigmadelpuntopiulontano2 * scalatore
#rhoeee=scalatore*rhoeee
#rhonii=scalatore*rhonii
puntopiulontanoyyy1 = scalatore * puntopiulontanoyyy1
puntopiulontanoxxx1 = scalatore * puntopiulontanoxxx1
puntopiulontanoyyy2 = scalatore * puntopiulontanoyyy2
puntopiulontanoxxx2 = scalatore * puntopiulontanoxxx2
if printa:
print(puntopiulontanoxxx1)
print(puntopiulontanoyyy1)
print(puntopiulontanoxxx2)
print(puntopiulontanoyyy2)
limitexminimo = minimo(listadicoordinatefinale[:, 0])
limitexmassimo = massimo(listadicoordinatefinale[:, 0])
limiteyminimo = minimo(listadicoordinatefinale[:, 1])
limiteymassimo = massimo(listadicoordinatefinale[:, 1])
alfa = 0.15 * (limiteymassimo - limiteyminimo)
beta = 0.15 * (limitexmassimo - limitexminimo)
limitexminimo = limitexminimo - beta
limitexmassimo = limitexmassimo + alfa
limiteyminimo = limiteyminimo - beta
limiteymassimo = limiteymassimo + alfa
ciccio = ((limitexmassimo - limitexminimo) +
(limiteymassimo - limiteyminimo)) * 0.2
assebaricentrototalex = (np.arange(0, 11))
assebaricentrototaley = (np.arange(0, 11))
assebaricentrototalenii = (np.arange(0, 11))
assebaricentrototaleeee = (np.arange(0, 11))
assebaricentrototalex[0] = limitexminimo
assebaricentrototaley[0] = baricentrototaley
assebaricentrototalex[1] = limitexmassimo
assebaricentrototaley[1] = baricentrototaley
assebaricentrototalex[2] = limitexmassimo - ciccio / 10
assebaricentrototaley[2] = baricentrototaley - ciccio / 30
assebaricentrototalex[3] = limitexmassimo - ciccio / 10
assebaricentrototaley[3] = baricentrototaley + ciccio / 30
assebaricentrototalex[4] = limitexmassimo
assebaricentrototaley[4] = baricentrototaley
assebaricentrototalex[5] = baricentrototalex
assebaricentrototaley[5] = baricentrototaley
assebaricentrototalex[6] = baricentrototalex
assebaricentrototaley[6] = limiteyminimo
assebaricentrototalex[7] = baricentrototalex
assebaricentrototaley[7] = limiteymassimo
assebaricentrototalex[8] = baricentrototalex - ciccio / 30
assebaricentrototaley[8] = limiteymassimo - ciccio / 10
assebaricentrototalex[9] = baricentrototalex + ciccio / 30
assebaricentrototaley[9] = limiteymassimo - ciccio / 10
assebaricentrototalex[10] = baricentrototalex
assebaricentrototaley[10] = limiteymassimo
assebaricentrototalenii[0] = (limitexminimo - baricentrototalex) * cos(
-Aangolo_rad) + (0) * sin(-Aangolo_rad) + baricentrototalex
assebaricentrototaleeee[0] = -(limitexminimo - baricentrototalex) * sin(
-Aangolo_rad) + (0) * cos(-Aangolo_rad) + baricentrototaley
assebaricentrototalenii[1] = (limitexmassimo - baricentrototalex) * cos(
-Aangolo_rad) + (0) * sin(-Aangolo_rad) + baricentrototalex
assebaricentrototaleeee[1] = -(limitexmassimo - baricentrototalex) * sin(
-Aangolo_rad) + (0) * cos(-Aangolo_rad) + baricentrototaley
assebaricentrototalenii[2] = (
limitexmassimo - ciccio / 10 -
baricentrototalex) * cos(-Aangolo_rad) + (
0 - ciccio / 30) * sin(-Aangolo_rad) + baricentrototalex
assebaricentrototaleeee[
2] = -(limitexmassimo - ciccio / 10 -
baricentrototalex) * sin(-Aangolo_rad) + (
0 - ciccio / 30) * cos(-Aangolo_rad) + baricentrototaley
assebaricentrototalenii[3] = (
limitexmassimo - ciccio / 10 -
baricentrototalex) * cos(-Aangolo_rad) + (
0 + ciccio / 30) * sin(-Aangolo_rad) + baricentrototalex
assebaricentrototaleeee[
3] = -(limitexmassimo - ciccio / 10 -
baricentrototalex) * sin(-Aangolo_rad) + (
0 + ciccio / 30) * cos(-Aangolo_rad) + baricentrototaley
assebaricentrototalenii[4] = (limitexmassimo - baricentrototalex) * cos(
-Aangolo_rad) + (0) * sin(-Aangolo_rad) + baricentrototalex
assebaricentrototaleeee[4] = -(limitexmassimo - baricentrototalex) * sin(
-Aangolo_rad) + (0) * cos(-Aangolo_rad) + baricentrototaley
assebaricentrototalenii[5] = (0) * cos(-Aangolo_rad) + (
0) * sin(-Aangolo_rad) + baricentrototalex
assebaricentrototaleeee[5] = -(0) * sin(-Aangolo_rad) + (
0) * cos(-Aangolo_rad) + baricentrototaley
assebaricentrototalenii[6] = (0) * cos(-Aangolo_rad) + (
limiteyminimo -
baricentrototaley) * sin(-Aangolo_rad) + baricentrototalex
assebaricentrototaleeee[6] = -(0) * sin(-Aangolo_rad) + (
limiteyminimo -
baricentrototaley) * cos(-Aangolo_rad) + baricentrototaley
assebaricentrototalenii[7] = (0) * cos(-Aangolo_rad) + (
limiteymassimo -
baricentrototaley) * sin(-Aangolo_rad) + baricentrototalex
assebaricentrototaleeee[7] = -(0) * sin(-Aangolo_rad) + (
limiteymassimo -
baricentrototaley) * cos(-Aangolo_rad) + baricentrototaley
assebaricentrototalenii[8] = (0 - ciccio / 30) * cos(-Aangolo_rad) + (
limiteymassimo - ciccio / 10 -
baricentrototaley) * sin(-Aangolo_rad) + baricentrototalex
assebaricentrototaleeee[8] = -(0 - ciccio / 30) * sin(-Aangolo_rad) + (
limiteymassimo - ciccio / 10 -
baricentrototaley) * cos(-Aangolo_rad) + baricentrototaley
assebaricentrototalenii[9] = (0 + ciccio / 30) * cos(-Aangolo_rad) + (
limiteymassimo - ciccio / 10 -
baricentrototaley) * sin(-Aangolo_rad) + baricentrototalex
assebaricentrototaleeee[9] = -(0 + ciccio / 30) * sin(-Aangolo_rad) + (
limiteymassimo - ciccio / 10 -
baricentrototaley) * cos(-Aangolo_rad) + baricentrototaley
assebaricentrototalenii[10] = (0) * cos(-Aangolo_rad) + (
limiteymassimo -
baricentrototaley) * sin(-Aangolo_rad) + baricentrototalex
assebaricentrototaleeee[10] = -(0) * sin(-Aangolo_rad) + (
limiteymassimo -
baricentrototaley) * cos(-Aangolo_rad) + baricentrototaley
#assebaricentrototalex=np.asmatrix(assebaricentrototalex)
#assebaricentrototaley=np.asmatrix(assebaricentrototaley)
#asse=UnireMatriciRig(transponi(assebaricentrototalex),transponi(assebaricentrototaley))
#aa=input("cazzo")
assenullox = (np.arange(0, 11))
assenulloy = (np.arange(0, 11))
assenullox[0] = limitexminimo
assenulloy[0] = 0
assenullox[1] = limitexmassimo
assenulloy[1] = 0
assenullox[2] = limitexmassimo - ciccio / 10
assenulloy[2] = 0 - ciccio / 30
assenullox[3] = limitexmassimo - ciccio / 10
assenulloy[3] = 0 + ciccio / 30
assenullox[4] = limitexmassimo
assenulloy[4] = 0
assenullox[5] = 0
assenulloy[5] = 0
assenullox[6] = 0
assenulloy[6] = limiteyminimo
assenullox[7] = 0
assenulloy[7] = limiteymassimo
assenullox[8] = 0 - ciccio / 30
assenulloy[8] = limiteymassimo - ciccio / 10
assenullox[9] = 0 + ciccio / 30
assenulloy[9] = limiteymassimo - ciccio / 10
assenullox[10] = 0
assenulloy[10] = limiteymassimo
#assenullox=np.asmatrix(assenullox)
#assenulloy=np.asmatrix(assenulloy)
#print(type(assenulloy))
#%assixy=[assenullox; assenulloy];
#%numerogiust0 e' 100 ma anche 50 va molto bene
"""
ellisse(:,1)=linspace(0,2*pi,100);
ellisse(:,2)=(rhonii**0.5)*cos(ellisse(:,1));
ellisse(:,3)=(rhoeee**0.5)*sin(ellisse(:,1));
ellisse(:,4)=baricentrototalex+ellisse(:,2)*cos(-Aangolo_rad)+ellisse(:,3)*sin(-Aangolo_rad);
ellisse(:,5)=baricentrototaley-ellisse(:,2)*sin(-Aangolo_rad)+ellisse(:,3)*cos(-Aangolo_rad);
#%matrice_di_ellisse=[ellisse(:,4),ellisse(:,5)]; """
if rhoeee > 0 and rhonii > 0:
nop = 100
el3 = np.arange(0, nop + 1)
el4 = np.arange(0, nop + 1)
#ellisse=np.linspace(0,2*pi,nop,endpoint=True)
#print(ellisse)
#print(type(ellisse))
Vet = range(0, nop)
for i in Vet:
angolo = 2 * pi * i / nop
el1 = el2 = 0
el1 = (rhonii**0.5) * (cos(angolo))
el2 = (rhoeee**0.5) * (sin(angolo))
#print(i,angolo,el1,el2)
el3[i] = baricentrototalex + scalatore * (+el1 *
(cos(-Aangolo_rad)) +
el2 *
(sin(-Aangolo_rad)))
el4[i] = baricentrototaley + scalatore * (-el1 *
(sin(-Aangolo_rad)) +
el2 *
(cos(-Aangolo_rad)))
angolo = 2 * pi
i = i + 1
el1 = (rhonii**0.5) * (cos(angolo))
el2 = (rhoeee**0.5) * (sin(angolo))
el3[i] = baricentrototalex + scalatore * (+el1 *
(cos(-Aangolo_rad)) + el2 *
(sin(-Aangolo_rad)))
el4[i] = baricentrototaley + scalatore * (-el1 *
(sin(-Aangolo_rad)) + el2 *
(cos(-Aangolo_rad)))
# print(i,angolo,el1,el2)
#print(noccioloordinato)
#print(noccioloordinato)
if vuoifareancheilnocciolo:
#size2(noccioloordinato,0)
neg = np.size(noccioloordinato, 0)
nocciolo1 = np.arange(0, neg + 1)
nocciolo2 = np.arange(0, neg + 1)
if printa:
print(noccioloordinato)
VetN = range(0, neg)
for k in VetN:
nocciolo1[k] = noccioloordinato[k, 0] * scalatore
nocciolo2[k] = noccioloordinato[k, 1] * scalatore
#print(k,noccioloordinato[k,0],noccioloordinato[k,1],nocciolo1[k],nocciolo2[k])
nocciolo1[k + 1] = noccioloordinato[0, 0] * scalatore
nocciolo2[k + 1] = noccioloordinato[0, 1] * scalatore
if printa:
print(nocciolo1, nocciolo2)
#print(k,noccioloordinato[k,0],noccioloordinato[k,1],nocciolo1[k],nocciolo2[k])
#nocciolox=[noccioloordinato(:,1);noccioloordinato(1,1)]
#noccioloy=[noccioloordinato(:,2);noccioloordinato(1,2)]
#print(nocciolo1)
#print(nocciolo2)
if vuoiplottare:
import matplotlib.pyplot as plt
#figsize=(11.69,8.27),dpi=600
fig = plt.figure()
#plt.clf()
#plt.rcdefaults()
if scherza:
plt.xkcd(scale=1, length=100, randomness=2, figure=fig)
if vuoiplottare:
coordinate = 0
from calcolatrice.studiatore2 import studianumero1
for i in VetFig:
calcolo = 5
cacca = numero1[i, :]
[coordinate, b1, b2, b3, b4, b5, b6, b7, b8,
peso_specifico] = studianumero1(cacca, kk, calcolo,
discretizzaarchicerchi, 0, 0)
if peso_specifico > 0:
#print(coordinate)
coordinate = np.dot(scalatore, coordinate)
vettore = size2(coordinate, 1)
#0print(size2(coordinate,0))
coordx = np.arange(0, vettore)
#print(coordx)
coordy = np.arange(0, vettore)
VetVettore = range(0, vettore)
for j in VetVettore:
coordx[j] = coordinate[j, 0]
coordy[j] = coordinate[j, 1]
if vuoiplottare:
if printa:
print(coordx, coordy) #plt.plot(coordx,coordy,"black")
plt.plot(coordx, coordy, "black", alpha=1, figure=fig)
plt.fill(coordx, coordy, "red", alpha=0.8, figure=fig)
figure_wgt = self.root.ids['figure_wgt'] # MatplotFigure
figure_wgt.figure = fig
#plt.fill(x,y)
#patch(coordinate(:,1)-traslax,coordinate(:,2)-traslay,"red")
for i in VetFig:
calcolo = 5
cacca = numero1[i, :]
[coordinate, b1, b2, b3, b4, b5, b6, b7, b8,
peso_specifico] = studianumero1(cacca, kk, calcolo,
discretizzaarchicerchi, 0, 0)
if peso_specifico < 0:
#print(coordinate)
coordinate = np.dot(scalatore, coordinate)
vettore = size2(coordinate, 1)
#0print(size2(coordinate,0))
coordx = np.arange(0, vettore)
#print(coordx)
coordy = np.arange(0, vettore)
VetVettore = range(0, vettore)
for j in VetVettore:
coordx[j] = coordinate[j, 0]
coordy[j] = coordinate[j, 1]
if vuoiplottare:
if printa:
print(coordx, coordy)
#plt.plot(coordx,coordy,"black")
plt.fill(coordx, coordy, "white", alpha=1, figure=fig)
plt.plot(coordx, coordy, "white", alpha=1, figure=fig)
figure_wgt = self.root.ids['figure_wgt'] # MatplotFigure
figure_wgt.figure = fig
if 0:
plt.plot(assenullox, assenulloy, "-", figure=fig)
plt.text(assenullox[1] + 0.05, assenulloy[1], 'Xo', figure=fig)
plt.text(assenullox[8], assenulloy[8], 'Yo', figure=fig)
plt.fill(assenullox[1:4],
assenulloy[1:4],
"blue",
alpha=1,
figure=fig)
plt.fill(assenullox[7:10],
assenulloy[7:10],
"blue",
alpha=1,
figure=fig)
plt.plot(assebaricentrototalenii,
assebaricentrototaleeee,
"green",
figure=fig)
plt.fill(assebaricentrototalenii[1:4],
assebaricentrototaleeee[1:4],
"green",
figure=fig)
plt.fill(assebaricentrototalenii[7:10],
assebaricentrototaleeee[7:10],
"green",
figure=fig)
#plt.text(assebaricentrototaleeee[1]-traslax,assebaricentrototalenii[1]-traslay,'Xi')
#plt.text(assebaricentrototaleeee[8]-traslax,assebaricentrototalenii[8]-traslay,'Yi')
plt.plot(assebaricentrototalex, assebaricentrototaley, "black")
plt.fill(assebaricentrototalex[1:4],
assebaricentrototaley[1:4],
"black",
alpha=1,
figure=fig)
plt.fill(assebaricentrototalex[7:10],
assebaricentrototaley[7:10],
"black",
alpha=1,
figure=fig)
plt.text(limitexmassimo, baricentrototaley - 0.05, 'Xg', figure=fig)
plt.text(baricentrototalex, limiteymassimo, 'Yg', figure=fig)
#plt.xlim([nuovolixmin,nuovolixmax])
#plt.ylim([nuovoliymin,nuovoliymax])
plt.plot(el3, el4, "green", figure=fig)
plt.fill(el3, el4, "black", alpha=0.1, figure=fig)
figure_wgt = self.root.ids['figure_wgt'] # MatplotFigure
figure_wgt.figure = fig
if vuoifareancheilnocciolo:
plt.plot(nocciolo1, nocciolo2, "black", figure=fig)
plt.fill(nocciolo1, nocciolo2, "black", alpha=0.5, figure=fig)
figure_wgt = self.root.ids['figure_wgt'] # MatplotFigure
figure_wgt.figure = fig
#######################################################################################
if sollecitazione[0, 0] == 1 or sollecitazione[0, 0] == 2:
#%angolo della traslazione del SdR Aangolo_rad
#%angolo della retta di nullomassimox angolo_rad
ptx1 = assenullox[0]
pty1 = assenulloy[0]
ptx2 = assenullox[1]
pty2 = assenulloy[1]
if printa:
print(Aangolo_rad, angolo_rad, pi / 2)
tootale = -Aangolo_rad - angolo_rad - pi / 2
rettadinullox = np.arange(0, 2)
rettadinulloy = np.arange(0, 2)
rettadinullox[0] = +(ptx1) * cos(tootale) + (
pty1) * sin(tootale) + baricentrototalex
rettadinulloy[0] = -(ptx1) * sin(tootale) + (
pty1) * cos(tootale) + baricentrototaley
rettadinullox[1] = +(ptx2) * cos(tootale) + (
pty2) * sin(tootale) + baricentrototalex
rettadinulloy[1] = -(ptx2) * sin(tootale) + (
pty2) * cos(tootale) + baricentrototaley
emmenulla = (rettadinulloy[0] - rettadinulloy[1]) / (rettadinullox[0] -
rettadinullox[1])
quellanulla = rettadinulloy[1] - emmenulla * rettadinullox[1]
pluslmax = np.abs((limitexmassimo - limitexminimo) / 20)
pluslmin = np.abs((limitexmassimo - limitexminimo) / 20)
rettadinullox[0] = limitexminimo - pluslmin
rettadinullox[1] = limitexmassimo + pluslmax
rettadinulloy[0] = rettadinullox[0] * emmenulla + quellanulla
rettadinulloy[1] = rettadinullox[1] * emmenulla + quellanulla
#print(rettadinullox,rettadinulloy)
#%il valore qui sotto non è giusto
if emmenulla == 0:
quellanormale = 9999999999999
else:
quellanormale = rettadinulloy[0] - (-1 /
emmenulla) * (rettadinullox[0])
quella1 = puntopiulontanoyyy1 - emmenulla * puntopiulontanoxxx1
limxnormale1 = (quellanormale - quella1) / (emmenulla + 1 / emmenulla)
limynormale1 = limxnormale1 * emmenulla + quella1
quella2 = puntopiulontanoyyy2 - emmenulla * puntopiulontanoxxx2
limxnormale2 = (quellanormale - quella2) / (emmenulla + 1 / emmenulla)
limynormale2 = limxnormale2 * emmenulla + quella2
rettanormalex = np.arange(0, 4)
rettanormaley = np.arange(0, 4)
rettanormalex[0] = puntopiulontanoxxx1
rettanormalex[1] = limxnormale1
rettanormalex[2] = limxnormale2
rettanormalex[3] = puntopiulontanoxxx2
rettanormaley[0] = puntopiulontanoyyy1
rettanormaley[1] = limynormale1
rettanormaley[2] = limynormale2
rettanormaley[3] = puntopiulontanoyyy2
#%sigmadelpuntopiulontano2=-1572.25;
#%sigmadelpuntopiulontano1=2438.17;
#%angolo_nullo=atan2(rettadinulloy(2)-rettadinulloy(1),rettadinullox(2)-rettadinullox(1));
fractor = 800
salto2 = sigmadelpuntopiulontano2
posixpt1x = limxnormale1 - (sigmadelpuntopiulontano1 /
fractor) * (cos(-tootale))
posixpt1y = limynormale1 - (sigmadelpuntopiulontano1 /
fractor) * (sin(-tootale))
posixpt2x = limxnormale2 - (salto2 / fractor) * (cos(-tootale))
posixpt2y = limynormale2 - (salto2 / fractor) * (sin(-tootale))
farfallax = np.arange(0, 4)
farfallay = np.arange(0, 4)
farfallax[0] = limxnormale1
farfallax[1] = posixpt1x
farfallax[2] = posixpt2x
farfallax[3] = limxnormale2
farfallay[0] = limynormale1
farfallay[1] = posixpt1y
farfallay[2] = posixpt2y
farfallay[3] = limynormale2
#str=['Sigma= ',num2str(x.sigmadelpuntopiulontano1)]
#text(posixpt1x+0.5,posixpt1y+0.5,str);
#str=['Sigma= ',num2str(x.sigmadelpuntopiulontano2)]
#text(posixpt2x-0.5,posixpt2y,str,'horizontalalignment', 'right')
plt.plot(rettadinullox, rettadinulloy, '-.', figure=fig)
plt.plot(rettanormalex, rettanormaley, '-.', figure=fig)
plt.fill(farfallax, farfallay, 'black', figure=fig)
figure_wgt = self.root.ids['figure_wgt'] # MatplotFigure
figure_wgt.figure = fig
#plt.title("Cercami su Facebook digitando Code:Section")
#if 0:
#from matplotlib import rc
#rc('font',**{'family':'sans-serif','sans-serif':['Helvetica']})
#rc('text', usetex=True)
#else:
#plt.rc('text', usetex=False)
#plt.title(stringa,loc="left")
#plt.plot(el3,el4,"g")
#fig.set_size_inches([11.69,8.27])
#plt.grid(True)
#plt.autoscale(True)
#plt.yscale('linear')
#plt.xscale('linear')
#plt.show(fig)
#if 0:
#import os
#a=os.getcwd()
#os.chdir(a+"\\risultati")
#from pathlib import Path
#import os
#via=os.getcwd()
#if printa:
# print(via)
#os.chdir(Path(via).parent)
#print(os.chdir(Path(via).parent))
#if printa:
#print("beeeeeh")
#fig.savefig("ciccio.png", dpi=600)
#plt.close(fig)
#os.chdir(via)
"""
%text(assebaricentrototalex(2)-0.5,assebaricentrototaley(2),'Xo');
%text(assebaricentrototalex(5),assebaricentrototaley(5),'Yo');
"""
return 1