← Back to branch summary

~ubuntu-branches/ubuntu/saucy/pyacidobasic/saucy

« back to all changes in this revision

Viewing changes to .pc/debian-changes-0.1-5/acidebase.py

  • Committer: Bazaar Package Importer
  • Author(s): Georges Khaznadar
  • Date: 2010-08-15 19:34:00 UTC
  • Revision ID: james.westby@ubuntu.com-20100815193400-ywmgp5v7hv0dhexm
Tags: 0.1-6
http://bugs.debian.org/593135
* fixed the versionless GPL reference
* upgraded Standards-Version to 3.9.1
* first release to Debian. Closes: #593135

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/debian-changes-0.1-5/acidebase.py
 
1
#-*- coding: utf-8 -*-
 
2
 
 
3
 
 
4
licence="""
 
5
    file acidebase.py: part of the package pyacidobasic version %s:
 
6
 
 
7
    Copyright (C) 2010 Georges Khaznadar <georgesk@ofset.org>
 
8
 
 
9
    This program is free software: you can redistribute it and/or modify
 
10
    it under the terms of the GNU General Public License as published by
 
11
    the Free Software Foundation, either version 3 of the License, or
 
12
    (at your option) any later version.
 
13
 
 
14
    This program is distributed in the hope that it will be useful,
 
15
    but WITHOUT ANY WARRANTY; without even the implied warranty of
 
16
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
17
    GNU General Public License for more details.
 
18
 
 
19
    You should have received a copy of the GNU General Public License
 
20
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
21
"""
 
22
 
 
23
from PyQt4.QtCore import *
 
24
from HTMLParser import *
 
25
 
 
26
class abHTMLparser(HTMLParser):
 
27
    """
 
28
    un analyseur de code HTML capable de construire une liste d'acides
 
29
    et de bases
 
30
    """
 
31
    def __init__(self,liste):
 
32
        HTMLParser.__init__(self)
 
33
        self.liste=liste
 
34
        self.ligne=False
 
35
        self.d=False
 
36
        self.input=""
 
37
        
 
38
    def handle_starttag(self, tag, attrs):
 
39
        if tag=="tr" :
 
40
            self.ligne=True
 
41
            self.ab=acideBase()
 
42
            self.gotAb=None
 
43
        elif tag=="td":
 
44
            self.d=True
 
45
            self.input=""
 
46
            if self.ligne:
 
47
                if self.gotAb == None: self.gotAb=0
 
48
                else: self.gotAb+=1
 
49
        elif self.ligne and self.d and (tag=="sup" or tag=="sub"):
 
50
            self.input+="<"+tag+">"
 
51
                
 
52
    def handle_data(self, data):
 
53
        if self.ligne and self.d:
 
54
            self.input+=data
 
55
            
 
56
    def handle_endtag(self, tag):
 
57
        if tag=="tr" :
 
58
            if self.gotAb:
 
59
                self.liste.append(self.ab)
 
60
            self.ligne=False
 
61
        elif tag=="td":
 
62
            if self.gotAb==0:
 
63
                formes=self.input.split(',')
 
64
                self.ab.formes=[]
 
65
                for f in formes:
 
66
                    f=unicode(f,"utf-8")
 
67
                    self.ab.formes.append(QString(f))
 
68
            elif self.gotAb==1:
 
69
                self.ab.formeIndex=   int(self.input)
 
70
            elif self.gotAb==2:
 
71
                self.ab.nom= QString(unicode(self.input,"utf-8"))
 
72
            elif self.gotAb==3:
 
73
                pKs=self.input.split(",")
 
74
                self.ab.pK=[]
 
75
                for pK in pKs:
 
76
                    self.ab.pK.append(float(pK))
 
77
            elif self.gotAb==4:
 
78
                self.ab.c= float(self.input)
 
79
            elif self.gotAb==5:
 
80
                self.ab.charge= int(self.input)
 
81
            else:
 
82
                raise Exception(rangeError, u"trop de données dans le fichier d'entrée")
 
83
            self.d=False
 
84
        elif self.ligne and self.d and (tag=="sup" or tag=="sub"):
 
85
            self.input+="</"+tag+">"
 
86
 
 
87
 
 
88
class acideBase:
 
89
    def __init__(self, formes=["AH","A<sup>-</sup>"], formeIndex=0, nom="acide générique", pK=[3.5], c=1.0, charge=0, v=0.0):
 
90
        """
 
91
        objet représentant un couple acido-basique
 
92
        @param formes la liste des formes acido-basiques conjuguées
 
93
        @param formeIndex la forme de base
 
94
        @param nom désignation de la forme de base
 
95
        @param pK liste des constantes d'acidité
 
96
        @param c concentration initiale en mol/L
 
97
        @param charge charge électrique de la forme acide en unité élémentaire
 
98
        @param v volume en mL
 
99
        """
 
100
        self.formes=formes
 
101
        self.formeIndex=formeIndex
 
102
        self.nom=nom
 
103
        self.pK=pK
 
104
        self.c=c
 
105
        self.charge=charge
 
106
        self.v=v
 
107
 
 
108
    def copie(self):
 
109
        return acideBase(self.formes, self.formeIndex, self.nom, self.pK,  self.c, self.charge, self.v)
 
110
 
 
111
    def __str__(self):
 
112
        return "%s;%s;%s;%s;%s;%s;%s" %(self.formes,
 
113
                                        self.formeIndex,
 
114
                                        self.nom,
 
115
                                        self.pK,
 
116
                                        self.c,
 
117
                                        self.charge,
 
118
                                        self.v)
 
119
    def chargeNette(self,pH):
 
120
        """
 
121
        Renvoie la charge électrique en Faraday en fonction du pH
 
122
        """
 
123
        concentrations=[1.0] # liste des concentrations des espèces
 
124
        total=1.0            # concentration totale
 
125
        for pK in self.pK:
 
126
            c=concentrations[-1]*10**(pH-pK)
 
127
            concentrations.append(c)
 
128
            total+=c
 
129
        # On normaliste pour que la concentration totale soit self.c
 
130
        concentrations=map(lambda c:c/total*self.c, concentrations)
 
131
        ch=self.charge # on considère la cahrge de l'espèce acide
 
132
        result=0.0
 
133
        # on calcule d'abord la concentration de charges
 
134
        for c in concentrations:
 
135
            result+=c*ch # on cumule la charge de l'espèce acide
 
136
            ch-=1        # et on passe à la base conjuguée
 
137
        # puis la charge en Faraday, en multipliant par le volume en mL.
 
138
        result*=self.v*1e-3   
 
139
        return result
 
140
    
 
141
def fromString(s):
 
142
    s=s.split(";")
 
143
    ab=acideBase()
 
144
    formes=s[0].split(',')
 
145
    ab.formes=[]
 
146
    for f in formes:
 
147
        f=unicode(f,"utf-8")
 
148
        ab.formes.append(QString(f))
 
149
    ab.formeIndex=   int(s[1])
 
150
    ab.nom=          QString(unicode(s[2],"utf-8"))
 
151
    pKs=s[3].split(",")
 
152
    ab.pK=[]
 
153
    for pK in pKs:
 
154
        ab.pK.append(float(pK))
 
155
    ab.c= float(s[4])
 
156
    ab.charge= int(s[5])
 
157
    return ab
 
158
 
 
159
def listFromString(s):
 
160
    liste=[]
 
161
    for ligne in s.split("\n"):
 
162
        try:
 
163
            acideOuBase=fromString(ligne)
 
164
            liste.append(acideOuBase)
 
165
        except:
 
166
            pass
 
167
    return liste
 
168
 
 
169
def listFromHTML(s):
 
170
    """
 
171
    remplit une liste d'acides/bases à partir de code HTML
 
172
    """
 
173
    liste=[]
 
174
    p=abHTMLparser(liste)
 
175
    p.feed(s)
 
176
    return liste
 
177
 
 
178
def listFromFile(fname):
 
179
    try:
 
180
        p=fname.index("html")
 
181
        if p>0:
 
182
            return listFromHTML(open(fname,"r").read(655360))
 
183
    except:
 
184
        pass
 
185
    return listFromString(open(fname,"r").read(655360))
 
186
                
 
187