Skip to content

Instantly share code, notes, and snippets.

@YannBouyeron
Created January 12, 2018 14:28
Show Gist options
  • Save YannBouyeron/dc1079cad958668ed78f361ab2442392 to your computer and use it in GitHub Desktop.
Save YannBouyeron/dc1079cad958668ed78f361ab2442392 to your computer and use it in GitHub Desktop.
gpconv.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#
# Copyright (c) 2017 Yann BOUYERON
#
#
# licensed under GNU GPL version 3 (or later)
#
#
#
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import numpy as np
def massvol(v, mi, voli, mf, volf):
"""La fonction massvol convertie des masses volumiques.
Unités de masses supportéés: g, kg, mg
Unités de volumes supportées: m3, cm3, km3, mm3, litre
v : type int or float
mi : l'unité de masse initiale - type str
voli : l'unité de volume initiale - type str
mf : l'unité de masse finale - type str
volf: l'unité de volume finale - type str"""
masse = {'g': 1, 'kg': 1000, 'mg': 1*10**-3}
volume = {'m3': 1, 'cm3': 1*10**-6, 'l': 0.001, 'km3': 1.10**9, 'mm3': 1*10**-9}
#conversion des masses
vf = v * masse[mi] / masse[mf]
#conversion des volumes
vf = vf *volume[volf] / volume[voli]
return vf
def convl (v,ui,uf):
"""
convl convertie n'importe quelle unité de longueur en n'importe quelle autre
****************************************************************************
Arguments:
v: la valeur de type float ou int
ui: unité initiale type str()
uf: unité finale type str()
Return:
r: la valeur convertie dans la nouvelle unité
****************************************************************************
"""
u = {'pico' : 10**-12,'A' : 10**-10,'nano': (10**-9), 'micro': (10**-6), 'mm' : (10**-3) , 'cm' : (10**-2) , 'm' : 1 , 'km':1000}
r = v * u[ui] / u[uf]
return r
def cmol(P,T):
"""
Calcule la concentration molaire en fonction de P et T
P est la pression atmosphérique (Pa) ou pression partielle du gaz: int ou float
T est la température (K) : int ou float
retourne cmol en moles par m3
V est le volume d’air (m3)
n est le nombre de moles d’air ou degaz
R est la constante des gaz parfaits (8,31 J K-1 mole-1 ou 8,2 x 10-5 atm m3 K-1 mole-1).
1 atm = 1.013*10**5 Pa
A P = 1 atm, donc au niveau de la mer, et T = 298 K (soit 25 °C) : n/V = 40,9 moles / m3
cmol = n / V = P / R*T
"""
R = 8.31
cmol = P / (R*T)
return cmol
def cmass(P,T,M):
"""Concentration massique (masse volumique). (g/m3)
P est la pression atmosphérique (Pa) ou pression partielle du gaz
T est la température (K)
M : masse molaire (en g.mol–1)
P,T,M sont de type int ou float
"""
return cmol(P,T) * M
def cmassah(hr,P,T):
"""Concentration massique (masse volumique) de l'air humide. (g/m3)
hr : humidité relative en absolue (exemple 0.76 et non pas 76%). float
P: pression atmospherique en pascal. int ou float
T: temperature en Kelvin. int ou float
"""
c = (1/(287.06*T))*(P-230.617*hr*np.exp((17.5043*k2c(T))/(241.2+k2c(T))))
c = c*1000
return c
def cmolec(P,T):
"""
La conversion de moles par volume d’air en molécules par volume d’air se fait avec le nombre d’Avogadro. Le nombre d’Avogadro, N, est le nombre de molécules par mole :
N = 6,023 x 10^23 molécules / mole.
return concentration moléculaire en molécules / m3
"""
N = 6.023*(10**23)
R = 8.2*10**(-5)
cmol = P / (R*T)
cmolec = cmol*N
return cmolec
def ppmtomol(ppm,T,P):
"""
convertion d'un fraction molaire en ppm en une concentration molaire en mol/m3
Arguments: ppm , T en (K), P la pression en (Pa)
Return: la concentration molaire en mol/m3
"""
R = 8.31
mol = (ppm*P)/(R*T*10**6)
return mol
def moltoppm(mol,T,P):
"""
convertion d´une concentration molaire en mol/m3 en une fraction molaire en ppm.
arguments: mol , T en (K), P la pression en (Pa)
return: la fraction molaire en ppm
"""
R = 8.31
ppm = (mol*R*T*10**6)/P
return ppm
def patm(alt):
"""
pression atmospherique (Pa) en fonction de l'atitude (m)
argument: altitude (m)
return: pression atmospherique (Pa)
"""
patm = 101325 * (1 - 0.0000225577 * alt) ** 5.2554876
return patm
def Vmol(T,P):
"""
volume molaire
arguments: T en (K), P en (Pa)
return: volume molaire en litre/mol
"""
R = 8.31
vmol = (R*T*10**3)/P
return vmol
def Ppart(alt,fm):
"""
pression partielle d'un gaz en fonction de la pression atmospherique calculée d'apres l'altitude
arguments: alt: altitude en m
FM: fraction molaire du gaz en %
return: pression partielle en Pa
"""
P = patm(alt)
Ppart = P * fm
return Ppart
def k2c(k):
"""
convertion des kelvin en celsuis
k: la temperature en kelvin. int ou float
retourne c : la temperature en celsuis
"""
c = k - 273.15
return c
def c2k(c):
"""
convertion des celsuis en kelvin
c: la temperature en celsuis. int ou float
retourne k : la temperature en kelvin
"""
k = c + 273.15
return k
def tempalt(alt):
"""retourne la temperature K moyenne theorique en fonction de l'altitude en m
on considere un gradiant thermique moyen de -6,5°C par km"""
t = 15 - (6.5*10**-3) * alt
k = c2k(t)
return k
def tempalt_grad(alt, T0, grad):
"""
Retourne la temperature K moyenne.
Arguments:
alt: l'altitude (float or int) en metres
T0: la temperature à 0 metre d'altitude (float or int)
grad: le gradient thermique en °C /km (float or int)
"""
t = T0 - (grad*10**-3) * alt
k = c2k(t)
return k
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment