gpconv.py

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