def __init__(self, *args, **kargs):
# def __init__(self, points=None, role=None, parent=None, name=''):
self.spline = None
dump = self.DEFAULT.copy()
"""Constructeur vide Polyline3D()"""
"""Constructeur recopie Polyline3D(une_instance_de_Polyline3D, name=..)"""
if len(args) > 1:
msg = """
Un seul argument non nommé autorisé, doit être de type Polyline3D.
pour constructeur recopie.
Ici, on a %d arguments non nommés de types : %s"""\
%(len(args),[className(a) for a in args])
raise TypeError(msg)
elif len(args) == 1:
#Un seul args, de type Polyline3D => constructeur recopie
if isinstance(args[0], Polyline3D):
dump.update(args[0].toDump())
else:
msg = """
Un seul argument non nomme autorisé, doit etre de type Polyline3D (pour constructeur recopie.)
Ici, 1 argument non nommé de type %s""" % (className(args[0]))
debug(msg)
raise TypeError
# else :#len(args)==0
dump.update(kargs)
self.load(dump)
# if not kargs and not args:
# else :
# self.load(dump)
# self.name = name
# self.parent = parent
if self.points.shape[0] > 2: self.update()
def moyenneMobileClosed(points, molecule=[1., 2., 1.], nnodes=None):
"""
Lissage moyenne mobile pour les polygones fermés self[-1]==self[0]
nnodes est la liste des numeros de points à lisser. On suppose que 0 n'y est pas
"""
molecule = np.asarray(molecule) #np.asarray([1., 2., 1.])/4.
molecule /= np.sum(np.absolute(molecule))
new = points
if nnodes is None:
nnodes = list(range(len(points)))
else:
nnodes.sort()
if nnodes[0] == 0 and nnodes[-1] == len(points):
debug('non implémenté')
return new
else:
pass
old = new[:-1]
n = len(old)
# deb, fin = 0, n
deb, fin = nnodes[0], nnodes[-1]
for k in range(deb, fin):
pm = old[k - 1]
p = old[k]
if k == n - 1:
pp = old[0]
else:
pp = old[k + 1]
new[k] = molecule[0] * pm + molecule[1] * p + molecule[2] * pp
new[-1] = new[0]
return new
def computeSurfaces(points, closed):
"""
Calcul des surfaces des panels définis par points
:param points:ndarray((nbn,nbpn,3),float) des points 3d d'un maillage régulier
Les panels sont délimités par points[i,j] points[i+1,j], points[i+1,j+1], p[i,j+1]
:param closed: bool
True si le bord de fuite est en double (points[k,-1]==points[k,0])
c'est le cas d'un maillage aerodynamique
False si non, c'est le cas du maillage elastique.
Dans ce cas, il faut rajouter un panel au bout de chaque caisson
"""
nbn, nbpn, _ = points.shape #ici les nervures sont fermées en BF... ou pas
debug(shape_points=(nbn, nbpn))
nbcais = nbn - 1
points = points.view().reshape((-1, 3))
nbpanels = nbcais * (nbpn - 1) if closed else nbcais * nbpn
debug(points=points.shape, nbpanels=nbpanels)
surf = zeros(nbpanels)
# debug(nbc=nbc, nbpn=nbpn, points=shape, surf=surf.shape)
# debug(self_nbp=nbp, self_nbn=nbn, self_nbpn=nbpn)
# exit()
for ip, panel in enumerate(panels((nbn, nbpn), closed)):
# if ip>=nbpanels-1 : debug(ip=ip, panel=panel)
sommets = [points[k] for k in panel]
surf[ip] = airePanel(*sommets)
# debug(p=p, panel=panel, surf=surf[p])
# celldata['surfaces'] = surf
# mesh.celldata = celldata
return surf
def alfaV(self, v0):
"""Retourne le alfa tel que V(alfa) = v0. Ne correspond pas à l'équilibre."""
# return newton(lambda alfa : self.V(alfa)-v0, radians(6.0), full_output=True, disp=False)
# except RuntimeError as msg : return nan
alfa, res = newton(lambda alfa: self.V(alfa) - v0,
radians(6.0),
tol=self.EPS,
full_output=True,
disp=False)
if res.converged:
return alfa % π
else:
alfa = res.root
res = dict(root=fmt(degrees(res.root)),
iterations=res.iterations,
function_calls=res.function_calls,
converged=res.converged,
cause=res.flag)
rn = norm(self.resultante(self.normalise(alfa)))
r = norm(self.resultante(alfa))
cm = fmt(self.CmT(alfa))
debug('alfaV : non CV')
print("alfa_normalisé = %s," % fmt(degrees(alfa % π)),
'resultante = (%s,%s),' % fmt((rn, r)), 'CmT =', cm)
print('résultats newton = ', fmt(res))
print()
if abs(r) < self.EPS:
return alfa % π
def suppressionPoints(P, S, C=[], debog=False):
"""
obsolete ??
Suppression points de P referencés par S, et mise à jour des connexions C
:param P: ndarray((nbp,dim),dtype=float ou int) tableau de points à nettoyer.
:param S: ndarray(ns, dtype=int), les n° de points à supprimer
max(S)<nbp.
:param C: ndarray(nc,dtype=int) tableau de n° de points à mettre à jour
max(C)<nbp.
- si C∩S = ∅, on ne supprime que des points non référencés dans C, RAS
- si C∩S ≠ ∅, pour i∈C∩S, dans C on remplace i par -9999
:return P, C: le tableau de points modifié et les connexions mises à jour.
"""
K = sorted(list(set(range(len(P))) - set(S))) #Keep
debug(K=K)
P = P[K]
S = list(S)
S.sort(reverse=True)
for ks in S:
if ks in K:
i = K.index(ks)
print('suppression de %d impossible' % ks)
else:
C[where(C > ks)] -= 1
# print("C=", C)
return P, C
def __rmul__(self, v):
""" Produit : v*self
- par un scalaire si v est réel
- vectoriel si v est Vecteur
"""
debug('rmult')
if isinstance(v, Vecteur):
return Vecteur(
-self.y * v.z + self.z * v.y,
-self.z * v.x + self.x * v.z,
-self.x * v.y + self.y * v.x,
)
else:
return Vecteur(self.x * v, self.y * v, self.z * v)
def equilibre(self, **kargs):
"""
:param kargs: les variables à modifier, parmi self.VARIABLES
:return:float, l'incidence alfa° telle que CmT(alfa)=0
>>> P = Parapente('diamir')
>>> eq = Equilibriste(P)
>>> alfa = eq.equilibre(c=29.0, mp=100.0, S=28.0, d=10.0)
# alfa sera l'incidence d'équilibre pour le parapente P,
# avec un calage c, un pilote de masse mp, une surface S, et 10% de freins
"""
objectif = self.CmT
def objectif(alfa):
"""
La fonction à annuler pour trouver l'équilibre
Peut être que return self.CmT(alfa) suffit...
"""
alfa = alfa % π
fx, fz = self.resultante(alfa)
return self.CmT(alfa)**2 + fx**2 + fz**2
return fx**2 + fz**2
if kargs: self.load(kargs)
#disp=False pour que newton ne lève pas une exception
alfa, res = newton(objectif,
radians(6.0),
tol=self.EPS,
full_output=True,
disp=False)
if res.converged:
return alfa % π
else:
alfa = res.root
res = dict(root=fmt(degrees(res.root)),
iterations=res.iterations,
function_calls=res.function_calls,
converged=res.converged,
cause=res.flag)
rn = norm(self.resultante(self.normalise(alfa)))
r = norm(self.resultante(alfa))
cm = self.CmT(alfa)
debug('Non CV', resultante=(rn, r), CmT=cm, res=res)
if abs(r) < self.EPS:
return alfa % π
# debug('Non CV', resultante=(fmt(rn,6), fmt(r,6)))
return nan
def safeRemoveTree(rep: Path):
if rep.isdir():
contents = sorted(os.listdir(rep))
elif rep.isfile():
contents = [rep]
if contents:
debug(paragraphe="Suppression de %s. Contenu :" % rep.name)
for c in contents:
c = Path(c)
if c.isdir(): print('%30s (D)' % c.name)
elif c.isfile(): print('%30s (F)' % c.name)
else: print('%30s (?)' % c.name)
else:
debug(paragraphe="%s est vide" % rep.name)
ans = 'w'
while ans not in ('y', 'n', ''):
ans = input('\nOK pour suppression ? y/n (defaut : n)').lower()
if ans == 'y':
rdebug("JE REMOVE %s" % rep)
return shutil.rmtree(rep)
else:
rdebug("CANCELLED REMOVE %s" % rep)
return None
def __init__(self):
# """conda list -n Axile --export > conda-packages.txt
# /bin/vikings -input eggs.txt -output "spam spam.txt" -cmd "echo '$MONEY'"""
# # cmd = 'conda list -n py3 --export > "conda-packages.txt"'
# # print (shlex.split(cmd))
#
# # exit()
# subprocess.run(["ls"],capture_output=True)
# exit()
# filename = SOURCES_DIR)/'conda-packages1.txt'
# condapath = os.path.expanduser('~'))/'anaconda2/condabin/conda'
# cmd = '%s list -n py3 --export > %s'%(condapath,filename)
# print(cmd)
# args = shlex.split(cmd)
# print(args)
# subprocess.run(args)
# exit()
# print(cmd)
# res = os.system(cmd)
# print(res)
# exit()
exes = ('ffmpeg', 'paraview', 'cmarc')
self.dexes = dict([(exe, None) for exe in exes])
packages = self.packages = [
'matplotlib', 'numpy', 'scipy', 'vtk', 'dxfwrite', 'dxfgrabber',
'shapely', 'cPickle', 'path', 'plotly'
]
self.lpack = [('Plateform', True, '', platform.platform(), ['']),
('Python', True, '', sys.version.replace('\n', ' -- '),
[sys.executable])]
for p in packages:
try:
exec('import ' + p)
value, msg = (True, '')
except Exception as msg:
value, msg = (False, str(msg))
debug(package=p, value=value, msg=str(msg))
if value:
if p in ('numpy', 'scipy', 'matplotlib', 'shapely'):
result = (p, True, '', eval(p + '.__version__'),
eval(p + '.__path__'))
elif p in ('vtk', ):
result = (p, True, '',
eval(p + '.vtkVersion.GetVTKVersion()'),
eval(p + '.__path__'))
elif p in ('dxfgrabber'): #,'dxfwrite') :
result = (p, True, '', eval(p + '.version'),
eval(p + '.__path__'))
elif p in ('path', 'cPickle'):
result = (p, True, '', eval(p + '.__version__'),
[str(eval(p + '.__file__'))])
else:
try:
v = eval(p + '.__version__')
except:
try:
v = eval(p + '.version')
except:
v = '???'
try:
pp = eval(p + '.__path__')
except:
try:
pp = [str(eval(p + '.__file__'))]
except:
pp = '???'
result = (p, True, '', v, pp)
else:
result = p, value, msg, None, None
# print 'result => ', result
self.lpack.append(result)
def _writeVariationMassePilote(self, Ms, fout):
eldump0 = self.toDump(
) #On le sauve car je crois qu'on le modifie un peu
eldump0['mp'] = '***'
print("\n\n", file=fout)
titre = sursouligne(" Variation masse pilote ", "=")
print(titre, file=fout)
if 0: print("paramètres :\n", fmt(eldump0), file=fout)
eldump0 = self.toDump(
) #On le sauve car je crois qu'on le modifie un peu
CZs, CXVs, CMVs, REs, Vs, VZs, CPs, FINs, CMTs = [], [], [], [], [], [], [], [], []
THETAs, ALPHAs, vols = [], [], []
for c in Ms:
try:
alfa = self.alfaEq(mp=c)
except RuntimeError as msg:
debug(msg, calage=c)
alfa = nan
idx, _ = self.typeDeVol(alfa)
vols.append('.' if idx == 0 else idx * "*")
ALPHAs.append(alfa * 180 / π)
FINs.append(self.finesse(alfa))
Vs.append(self.V(alfa) * 3.6)
VZs.append(self.Vz(alfa))
CPs.append(100 * self.CP(alfa))
THETAs.append(self.θ(alfa) * 180 / π)
r = self.resultante(alfa)
REs.append(abs(r[0]) + abs(r[1]) + abs(self.CmT(alfa)))
CMTs.append(self.CmT(alfa))
CZs.append(self.Cz(alfa))
CXVs.append(self.Cxv(alfa))
CMVs.append(self.Cmv(alfa))
rdebug(vols)
print("---------------------|" + "-".join([7 * '-' for c in Ms]),
file=fout)
print(" masse pilote (kg) |",
" ".join(['%-7.2f' % c for c in Ms]),
file=fout)
print("---------------------|" + "-".join([7 * '-' for c in Ms]),
file=fout)
# if not any(vols) :
print(" Type de vol |",
" ".join(['%-7.2s' % c for c in vols]),
file=fout)
print(" Incidence (°) |",
" ".join(['%-7.2f' % c for c in ALPHAs]),
file=fout)
print(" Vitesse (km/h) |",
" ".join(['%-7.2f' % c for c in Vs]),
file=fout)
print(" Vz (m/s) |",
" ".join(['%-7.2f' % c for c in VZs]),
file=fout)
print(" Finesse |",
" ".join(['%-7.2f' % c for c in FINs]),
file=fout)
print(" Assiette (°) |",
" ".join(['%-7.2f' % c for c in THETAs]),
file=fout)
print(" Centre poussee (%) |",
" ".join(['%-7.2f' % c for c in CPs]),
file=fout)
print("---------------------|" + "-".join([7 * '-' for c in CPs]),
file=fout)
print(" Cz |",
" ".join(['%-7.2f' % c for c in CZs]),
file=fout)
print(" Cx voile |",
" ".join(['%-7.2f' % c for c in CXVs]),
file=fout)
print(" Cm voile |",
" ".join(['%-7.2f' % c for c in CMVs]),
file=fout)
print("---------------------|" + "-".join([7 * '-' for c in CPs]),
file=fout)
print(" Resultante(=0 ?) |",
" ".join(['%-7.0g' % c for c in REs]),
file=fout)
print(" Moment(=0 ?) |",
" ".join(['%-7.0g' % c for c in CMTs]),
file=fout)
print("---------------------|" + "-".join([7 * '-' for c in Ms]),
file=fout)
self.load(eldump0)
def __init__(self, **kargs):
"""
Calcul approximatif de l'équilibre en vol droit, à vitesse constante,
de la voile <session>, à partir des data (globales) calculées par Cmarc
(ou un autre simulateur aérodynamique).
Les coordonnées sont exprimées dans le repère voile,
d'origine le bord d'attaque du caisson central, de vecteurs iv,jv,kv,
- iv porté par la corde centrale, vers l'arrière,
- jv vers la gauche,
- kv vertical, vers le haut.
Sauf précision, les unités sont en S.I. (Mètre, Kilogramme, Seconde).
Variables globales, dans aperoconfig
------------------------------------
:param session : str, nom de la voile
(new avril 2019 deux variables globales dans aperoconfig(=ac) :
=> session=AC.SESSION, et
=> parapente=AC.PARAPENTE).
:param parapente : Parapente => self.parapente
Si 'parapente' est absent, on utilise AC.PARAPENTE
:param session : str, le nom de la session. Inutilisé, on récupère celui de self.parapente
Variables calculés par self.parapente.data2d()
--------------------------------------------
:param b : float, demi-envergure vraie.
:param S : float, surface vraie.
:param l : float, corde centrale vraie.
:param s : longueur du cône de suspentage.
P et Q étant la position du pilote et la projection orthogonlre du
pilote sur la corde centrale, s=dist(P,Q).
:param xGv,zGv : float, float, position du centre de gravité de la voile
xGv>0, zGv<0.
Variables par défaut dans <DATA_DIR>/preferences/equilibre2d.dat
----------------------------------------------------------------
puis écrasées <session>.equilibre2d.dat
---------------------------------------
:param mp: float, masse pilote.
:param d: pourcentage de frein ∈ [0.0, 100.0] => non implémenté
:param Cxp : coefficients de traînée pilote.
[TODO : a faire calculer par PARAPENTE]
---------------------------------------
:param mv:float, masse voile seule, NON compris la masse 'ma' d'air emprisonné,
dont le poids est intégralement compensé par la force d'Archimède.
Lorsque l'on s'intéressera à la DYNAMIQUE du parapente, il faudra prendre
'ma' en compte
:param ma:float, masse d'air emprisonné dans la voile [non utilisé actuellement]
:param c: float, calage, i.e. position de Q en %de corde centrale
i.e. AQ/b, A=bord d'attaque au centre de la voile.
:param zs: float, altitude du point d'application de la trainée suspente.
zs<0.
:param Cxs : coefficients de traînée suspentage.
:param Cx0: float, coefficient de traînée voile (frottement).
Fonctions et param. retournées par Polaires
-------------------------------------------
:param b0 : float, demi-envergure de référence (utilisée par Cmarc).
:param S0 : float, surface de référence (utilisée par Cmarc).
:param l0 : float, corde de référence (utilisée par Cmarc).
:param Cx : fonction (quadratique ou spline) de l'incidence, le
coefficient de trainée voile fourni par la simulation Cmarc.
:param Cz : fonction (quadratique, linéaire ou spline) de l'incidence,
le coefficient de portance, fourni par la simulation Cmarc.
:param Cm : fonction (quadratique, linéaire ou spline) de l'incidence,
le coefficient de moment par rapport au BA, fourni par la
simulation Cmarc.
NB : les trois dernières fonctions sont des fonctions f(alfa) qui
prennent en argument 'alfa' l'incidence
Cmarc fournit les trois fonctions aérodynamiques de 'alfa' pour la voilure
seule alfa -> Cz(alfa), Cx(alfa), Cm(alfa)
:TODO: l'influence des freins 'd' doit être évaluée par ailleurs...
NB (mars 2019): pour obtenir la position de la voile en soufflerie, à vitesse V
donnée, il suffit d'utiliser le simulateur itérativement avec une charge
(poids pilote) variable, jusqu'a obtenir une vitesse de vol = V
La méthode self.alfaV(v0) fait le job
[Fixed] => NB (mars 2019) ATTENTION,
cmarc donne le moment des forces par rapport au point
BINP9{..., 'RMPX': 0.0, 'RMPY':0.0, 'RMPZ':0.0}
valeur par defaut qu'on retrouve dans tous les cmi et cmo
"""
raise NotImplementedError(
"""29 Oct. 2019. Non fonctionnel, le point de référence pour les moments n'est pas utilisé.
Cf equilibre.py et aide/simul_FFVL_tests_structure.py""")
# if len(args)>0 :
# msg = """
# Tous les arguments doivent être nommés.
# On a %d argument(s) non nommé(s), de type(s) %s.
# """%(len(args),[className(a for a in args)])
# raise ValueError(msg)
#valeurs par defaut
dump = readPyData(DATA_DIR / 'preferences' / 'equilibre2d.dict')
# with open(DATA_DIR/'preferences'/'equilibre2d.dict') as f :
# dump = eval(f.read())
#le parapente
if 'parapente' in kargs:
self.P = kargs.pop('parapente')
else:
self.P = AC.PARAPENTE
self.parapente = self.P
#On va chercher les valeurs de b, S, l, xGv,zGv, c, zs dans le parapente
if 'data2d' in kargs:
dp = kargs['data2d']
else:
dp = self.P.data2d
# dp = OrderedDict(sorted([(key,dp[key]) for key in dp]))
debug(self.session, data_defaut=ordered(dump))
debug(self.session, data_parapente=ordered(dp))
dump.update(dp)
#on va chercher les valeurs de b0, S0,.. et les fonctions Cx, Cz..
#dans Polaires il faut que <session>.polaires existe ou que
#les simulations (.cmo) existent en nombre suffisant (>3)
lookup = 'polaires' not in kargs and not self.P.polairesfile.isfile()
if lookup:
debug("""Patience ! Relecture de toutes les simulations,
calcul et sauvegarde des polaires %r""" % self.P.session)
else:
try:
debug('%r existe : %s' %
(self.P.polairesfile.name, not lookup))
except AttributeError:
pass
if 'polaires' in kargs:
pol = kargs['polaires']
if self.P is not None:
pol = Polaires(session=self.P.session,
lookupdata=lookup) #.toDump()
if lookup: pol.dump()
dump.update(CxvCMARC=lambda alfa: pol.Cx(alfa % π),
Cmv=lambda alfa: pol.Cm(alfa % π),
Cz=lambda alfa: pol.Cz(alfa % π),
b0=pol.b0,
l0=pol.l0,
vinf=pol.vinf,
S0=pol.S0,
session=self.session)
#On écrase tout par les paramètres d'entrée
dump.update(kargs)
#on se débarasse du paramètre session qui est en @property
if 'session' in dump:
dump.pop('session')
#On a toutes les data dans dump, on peut instancier les attributs
for key, value in dump.items():
setattr(self, key, value)
# ne pas oublier, pour calculer les différentes constantes utiles.
self.load()
def loadFromAllSimulations(self, resume=True):
"""On recharge les résultats des simulations :
- si resume=True on relit uniquement les fichiers résumé,
- sinon, on load les fichiers cmo et on cree les résumés
un fichier résumé se lit avec readPyData, c'est un dict constitué ainsi :
'dims' : dict, les dimensions nbp, nbn, nbpn, nbcells, nbsect sont les nombres de
points, nervures, points par nervure, panels, sections (ou caissons)
'convergence' : bool, True si les itérations Cmarc ont convergé.
'inputdata' : dict, les paramètres passés à cmarc
incidence, dérapage, nb timestep etc., cf fichier .cmi
'glob' : list, pour chaque pas de temps, un dictionnaire qui contient
les coefficients aerodynamiques globaux, dans le repere aerodynamique,
calcules par Cmarc.
NOTE1: si la geometrie est decrite avec une symetrie par rapport au plan Y=0,
(parametre RSYM=0) les coefficients ne tiennent compte que de la demi voile.
NOTE2: on suppose que l'assemblage cmarc n'a qu'un seul composant 'Voile'
'local' : list, pour chaque caisson, un dictionnaire des
coefficients aerodynamiques locaux (du caisson), calcules par Cmarc,
exprimes dans le repere aerodynamique, et calcules au DERNIER pas de temps
"""
allsim = allSimulations(AC.SESSION, resume)
alfadegs, yawdegs, Czs, Cxs, Cms = [], [], [], [], []
areas, S0s, vinfs, b0s, l0s, refms = [], [], [], [], [], []
debug(titre='''Patience''')
print(
'''- je relis les simulations, \n- je vérifie leur compatibilité, \n- et je construit les polaires\n'''
)
for _, sim in enumerate(allsim[:]):
print(str(sim))
# debug('>>>> Simulation %s\n'%cmo.session)
# sim = SimulationAero(cmo)
if not sim.hasConverged(): continue
# lecteur = postaero.lecteur
# d = coefs = sim.getGlobalCoeffs()['Voile']
# debug(coefs.keys())
alfadeg = sim.alfa
if alfadeg in alfadegs:
continue
yawdeg = sim.yaw
vinf = sim.vinf #Vitesse ref
S0 = sim.sref #Surface ref
b0 = sim.sspan #1/2 envergure ref
l0 = sim.cbar #Corde ref
#Point de référence pour moment tangage
refm = sim.rmpx, sim.rmpy, sim.rmpz
# vinf = d['vinf']#Vitesse ref
# S0 = d['sref']#Surface ref
# b0 = d['sspan']#1/2 envergure ref
# l0 = d['cbar']#Corde ref
# #Point de référence pour moment tangage
# refm = d['rmpx'],d['rmpy'],d['rmpz']
# debug(entete=d)
# debug('entete')
# pprint(d)
# debug('Coefs aero')
# pprint(F)
# coefs = F['Voile']
Cz, Cx, Cm, area = sim.CL, sim.CD, sim.C_m, sim.area * S0
alfadegs.append(alfadeg)
yawdegs.append(yawdeg)
Czs.append(Cz)
Cxs.append(Cx)
Cms.append(Cm)
vinfs.append(vinf)
areas.append(area)
S0s.append(S0)
b0s.append(b0)
l0s.append(l0)
refms.append(refm)
alfas = radians(alfadegs)
yaws = radians(yawdegs)
self.alfadegs = tuple(alfadegs)
self.yawdegs = tuple(yawdegs)
T = list(
zip(*sorted(
zip(alfadegs, alfas, yawdegs, yaws, Czs, Cxs, Cms, areas, S0s,
vinfs, b0s, l0s, refms))))
(self.alfadegs, self.alfas, self.yawdegs, self.yaws, self.Czs,
self.Cxs, self.Cms, self.areas, self.S0s, self.vinfs, self.b0s,
self.l0s, self.refms) = T
self.verifications()
def plot(self, **kargs):
"""TODO : tracés pour variation calage, longueur cône suspentage, CxV, Cxs, Cxp,..."""
# csfont = {'fontname':'Comic Sans MS'}
hfont = {'fontname': 'Liberation Serif'}
if not kargs:
kargs = readPyData(Path(DATA_DIR) / 'preferences' / 'aero2d.dict')
if 'mp' in kargs:
Vs, VZs, CPs, FINs, ALPHAs = [], [], [], [], []
Mp = kargs['mp']
for m in Mp:
alfa = self.alfaEq(mp=m)
if alfa < 0:
# alfa = self.normalise(alfa)
debug('Fermeture, vol impossible; alfa=%s' %
fmt(degrees(alfa)))
alfa = nan
alfa = alfa % π
# idx, _ = self.typeDeVol(alfa)
# typevols.append(' .' if idx==0 else ' '+idx*"*")
ALPHAs.append(alfa * 180 / π)
FINs.append(self.finesse(alfa))
Vs.append(self.V(alfa) * 3.6)
VZs.append(self.Vz(alfa))
CPs.append(100 * self.CP(alfa))
r = self.resultante(alfa)
# REs.append(abs(r[0]) + abs(r[1]) + abs(self.CmT(alfa)))
# CMTs.append(self.CmT(alfa))
# CZs.append(self.Cz(alfa))
# CXVs.append(self.Cxv(alfa))
# CMVs.append(self.Cmv(alfa))
# adeg = linspace(min(self.alfadegs), max(self.alfadegs), 100)
# arad = linspace(min(self.alfas), max(self.alfas), 100)
# Cxs, Czs = self.Cx(arad), self.Cz(arad)
debug(finesses=fmt(FINs))
debug(Vz=fmt(VZs))
fig = plt.figure()
ax1 = fig.add_subplot(221)
ax2 = fig.add_subplot(222, sharex=ax1)
ax3 = fig.add_subplot(223, sharex=ax1)
ax4 = fig.add_subplot(224, sharex=ax1)
# ax4.set_xlim(left=0.0, right=max(Cxs))
# ax4.set_ylim(bottom=0.0, top=max(Czs))
ax1.plot(Mp, FINs, 'b.-') #, label='$ \\phi $')
# ax1.plot(self.alfadegs, self.Czs, 'b.', label='data')
# ax1.legend()
ax1.set_xlabel('$ m_p (kg) $')
ax1.set_ylabel('$ \\phi $')
ax1.set_title('Finesses', **hfont)
ax2.plot(Mp, Vs, 'b.-') #, label='$V$')
ax2.set_xlabel('$ m_p (kg) $ ')
ax2.set_ylabel('$ V (km/h) $')
ax2.set_title('Vitesse sur trajectoire (km/h)', **hfont)
# ax2.legend()
ax3.plot(Mp, VZs, 'b.-') #, label='data')
ax3.set_ylabel('$ V_z (m/s) $')
ax3.set_title('Taux de chute (m/s)', **hfont)
if 0:
ax4.plot(Mp, ALPHAs, 'b.-') #, label='data')
ax4.set_ylabel('$ \\alpha (°) $')
ax4.set_title('Incidences', **hfont)
if 1:
ax4.plot(Mp, CPs, 'b.-') #, label='data')
ax4.set_ylabel('$ CP $ ')
ax4.set_title('Centre de poussée % de corde', **hfont)
fig.suptitle(
'Session %s : variation de la masse pilote $m_p$\n' % AC.SESSION,
**hfont)
plt.tight_layout()
plt.show()
def _writeVariationCalage(self, Cs, fout):
eldump0 = self.toDump()
eldump0['c'] = '###'
titre = sursouligne(" Variation calage ", "=")
print("\n\n", file=fout)
print(titre, file=fout)
if 0: print("paramètres:\n", fmt(eldump0), file=fout)
eldump0 = self.toDump()
CZs, CXVs, CMVs, REs, Vs, VZs, CPs, FINs, CMTs = [], [], [], [], [], [], [], [], []
THETAs, ALPHAs, typevols = [], [], []
for c in Cs:
try:
alfa = self.alfaEq(c=c)
except RuntimeError as msg:
debug(msg, calage=c)
alfa = nan
# continue
if alfa < 0:
alfa = nan
alfa = alfa % π
debug('Fermeture, vol impossible')
idx, _ = self.typeDeVol(alfa)
typevols.append(' .' if idx == 0 else ' ' + idx * "*")
ALPHAs.append(alfa * 180 / π)
FINs.append(self.finesse(alfa))
Vs.append(self.V(alfa) * 3.6)
VZs.append(self.Vz(alfa))
CPs.append(100 * self.CP(alfa))
THETAs.append(self.θ(alfa) * 180 / π)
r = self.resultante(alfa)
REs.append(abs(r[0]) + abs(r[1]) + abs(self.CmT(alfa)))
CMTs.append(self.CmT(alfa))
CZs.append(self.Cz(alfa))
CXVs.append(self.Cxv(alfa))
CMVs.append(self.Cmv(alfa))
print("---------------------|" + "-".join([7 * '-' for c in CPs]),
file=fout)
print(" Calage (% de corde) |",
" ".join(['%-7.1f' % (100 * c) for c in Cs]),
file=fout)
print(" Type de vol |" +
" ".join(['%-7s' % c for c in typevols]),
file=fout)
print("---------------------|" + "-".join([7 * '-' for c in CPs]),
file=fout)
print(" Incidence (°) |",
" ".join(['%-7.2f' % c for c in ALPHAs]),
file=fout)
print(" Vitesse (km/h) |",
" ".join(['%-7.2f' % c for c in Vs]),
file=fout)
print(" Vz (m/s) |",
" ".join(['%-7.2f' % c for c in VZs]),
file=fout)
print(" Finesse |",
" ".join(['%-7.2f' % c for c in FINs]),
file=fout)
print(" Assiette (°) |",
" ".join(['%-7.2f' % c for c in THETAs]),
file=fout)
print(" Centre poussee (%) |",
" ".join(['%-7.2f' % c for c in CPs]),
file=fout)
print("---------------------|" + "-".join([7 * '-' for c in CPs]),
file=fout)
print(" Cz |",
" ".join(['%-7.2f' % c for c in CZs]),
file=fout)
print(" Cx voile |",
" ".join(['%-7.2f' % c for c in CXVs]),
file=fout)
print(" Cm voile |",
" ".join(['%-7.2f' % c for c in CMVs]),
file=fout)
print("---------------------|" + "-".join([7 * '-' for c in CPs]),
file=fout)
print(" Resultante(=0 ?) |",
" ".join(['%-7.0g' % c for c in REs]),
file=fout)
print(" Moment(=0 ?) |",
" ".join(['%-7.0g' % c for c in CMTs]),
file=fout)
print("---------------------|" + "-".join([7 * '-' for c in CPs]),
file=fout)
#On rétablit dans sa config originale
self.load(eldump0)
# self.R.setCoord(tors_R)
# self.M.setCoord(M)
def copy(self, A=None):
t = Torseur(A=self.A.copy(), R=self.R.copy(), M=self.M.copy())
# t = Torseur()
# t.R.setCoord(self.R)
# t.M.setCoord(self.M)
# t.A.setCoord(self.A)
if A is not None and t.A != A:
t.A = A
return t
if __name__ == '__main__':
from pytictoc import TicToc
if 0:
debug(titre='test Point')
P = Point(1, 0, 0)
idP = id(P)
print("P = %r" % P)
P1 = Point(1, 1, 1)
idP1 = id(P1)
cP = P.copy()
print('P == P.copy() :', P == P.copy())
print('id(P) == id(P.copy()) :',
id(P) == id(P.copy())) #, 'P==P.copy() :',P==P.copy())
# P1 = P
# print('id(P)==id(P1)',id(P)==id(P1))#, 'P==P.copy()',P==P.copy())
V = Vecteur(2, 2, 3)
print('V = %r' % V)
P += V
def splineInterpolation(points, methode='c cubic', tension=5, degre=3):
"""
Une paire de spline cubiques paramétriques qui interpole ou ajuste le polygone points
sx(t), sy(t) sont deux splines.
Voir la doc Scipy.interpolate...
- si methode dans {'x cubic', 'ius','periodic','interp1d',} c'est de l'interpolation
- si methode est {'us','univariatespline'} c'est de l'ajustement, le poids est 1 pour tous les points
Retourne:
--------
T = les valeurs du paramètre t, abscisse curviligne NORMALISEE, entre 0 et 1.
sx, sy = les deux splines
"""
if methode in (
'periodic',
'p cubic',
):
if all(points[0] == points[-1]): pass
else: #On rajoute le premier point a la fin
points = vstack((points, points[0]))
# points.resize((1+len(points),2)) #moins cher que vstack mais marche pas !!
# points[-1] = points[0]
if tension == 0.0:
eps = 0.0
else:
eps = 10.0**(-tension)
N = len(points)
T = absCurv(points)
if len(points) < 2: return T, None, None
T /= T[-1]
X = points[:, 0]
Y = points[:, 1]
try:
methode = methode.lower()
except AttributeError:
pass
# debug(None, methode=methode, tension=tension, degre=degre)
if methode in ('ius', 'interpolatedunivariatespline'):
try:
sx = InterpolatedUnivariateSpline(
T, X,
k=degre) #s=la précision de l'ajustement s=0 <=> interpolation
sy = InterpolatedUnivariateSpline(T, Y, k=degre)
except Exception as msg:
debug(None)
print((str(msg)))
# debug(None,u'Impossible de calculer la testspline (pas assez de points ?, degré trop élévé ?)')
sx = sy = None
elif methode in ('us', 'univariatespline'):
try:
weights = ones(N)
W = 1000.0
# en supposant que tous les termes erreur di^2=wi*(xi-f(ti))^2 sont egaux
# le choix de s suivant implique
# abs(xi-f(ti))<eps et
# abs(x1-f(t1))<eps/(N*W) et abs(xN-f(tN))<eps/(N*W)
# eps = 10.0**(-tension)
weights[0] = weights[-1] = W
weights /= sum(weights)
s = eps / (N * W)
sx = UnivariateSpline(
T, X, w=weights, k=degre,
s=s) #s=la précision de l'ajustement s=0 <=> interpolation
sy = UnivariateSpline(T, Y, w=weights, k=degre, s=s)
except Exception as msg:
debug(None)
print((str(msg)))
# debug(None,u'Impossible de calculer la testspline (pas assez de points ?, degré trop élévé ?)')
sx = sy = None
elif methode in ('interp1d', ):
try:
sx = interp1d(T, X, kind=degre)
sy = interp1d(T, Y, kind=degre)
except ValueError as msg:
debug(None)
print((str(msg)))
sx = sy = None
# elif methode in ('periodic',) :
# try :
# sx = PeriodicSpline(T, X, k=degre, s=eps)
# sy = PeriodicSpline(T, Y, k=degre, s=eps)
# except ValueError as msg:
# debug(None)
# print unicode(msg)
# sx = sy = None
elif 'cubic' in methode: #or isinstance(methode, (tuple, list, np.ndarray)):
if methode == 'p cubic': bc_type = 'periodic'
elif methode == 'c cubic': bc_type = 'clamped'
elif methode == 'n cubic': bc_type = 'natural'
else: bc_type = 'not-a-knot'
try:
# debug(None, T)
sx = CubicSpline(T, X, bc_type=bc_type)
sy = CubicSpline(T, Y, bc_type=bc_type)
except ValueError as msg:
print((str(msg)))
sx = sy = None
elif isinstance(methode, (tuple, list, ndarray)):
bc_type = methode
try:
# debug(None, T)
sx = CubicSpline(T, X, bc_type=bc_type)
sy = CubicSpline(T, Y, bc_type=bc_type)
except ValueError as msg:
print((str(msg)))
sx = sy = None
return T, sx, sy
