def goDistance2(selection, Latm, contrainte, eigenvectors, natm, C):
"""Lance l'optimisation des poids pour maximiser la distance
de la selection selon la contrainte donnée par l'utilisateur
-Args:
_selection: la selection de numéro d'atomes pour lesquel on veut contraindre la distance
sous forme de liste de listes de paires
_Latm: la liste d'atomes
_contrainte: le ratio d'augmentation ou de diminution de la distance moyenne de la selection
_eigenvectors: les vecteurs propres selectionés
_natm:le nombre d'atomes
_C: configuration
"""
distInit = np.mean(calcDistance(selection,
Latm)) # calcule la sas de la selection
contrainte = contrainte * distInit # définition de la contrainte
# modeE = 0
aj = 1 # permet d'aller vers une augmententation ou diminution la distance
if distInit > contrainte:
aj = -1
distmax, distDefault = distInit, distInit
print("Distance initiale des atomes de la selection {} : {:.3f}".format(
selection, distInit))
w = W.Weights(len(eigenvectors)) # initialisation des poids (aléatoire)
prgs, d = 0, 0 # d : pas de temps utilisé, prgs : décompte des itérations
Distances = []
while contrainte * aj > distInit * aj and prgs < C.niter: # tant que la contrainte n'est pas satisfaite et que le nombre d'iteration nest pas atteint
w.reajustWeights(prgs) # reajustement des poids
t1 = time.time()
Latm = ReturnDisplacedLatm(
Latm, eigenvectors, natm, d, w.weights,
C) # deplacement des atomes selon les modes pondérés
t2 = time.time()
distInit = np.mean(
calcDistance(selection, Latm)
) # calcul de la surface accessible au solvent après déplacement
t3 = time.time()
if distInit * aj > distmax * aj: # si sas init est depasse et que iterations post saturation
w.reajustLimits(
prgs) # reajustement des bornes des poids (entre -1 et 1)
w.saveCombinaisonMax(d) # sauvegarder cette combinaison
distmax = distInit
Distances = []
print("Etape {}, évolution de la distance : {:.3f}".format(
prgs, aj * (distInit - distDefault)))
# retrieveData(prgs,(distInit- distDefault),C,modeE)
# modeE+=1
else:
Distances, w = W.watch(distInit, Distances, w)
w.precState(
) # retourne au vecteur de poids précédent si pas d'amélioration
# print("Seconds = {:.2f} , {:.2f}, {:.2f}".format((t2-t1),(t3-t2),(((t3-t2)-(t2-t1)))))
prgs += 1
return [Latm, w]
def goSurface(selection, Latm, contrainte, eigenvectors, natm, C):
"""Lance l'optimisation des poids pour maximiser la suface accessible au solvent
de la selection selon la contrainte donnée par l'utilisateur
-Args:
_selection: la selection d'acide aminés pour le calcul de surface accessible
au solvant, abrégé sasa ou sas
_Latm: la liste d'atomes
_contrainte: le ratio d'augmentation ou de diminution de la sasa pour la selection
_eigenvectors: les vecteurs propres selectionés
_natm:le nombre d'atomes
_C: configuration
"""
saInit = calcSASA(Latm, selection) # calcule la sas de la selection
contrainte = contrainte * saInit # définition de la contrainte
modeE = 0
aj = 1 # permet d'aller vers une augmententation ou diminution la sas
if saInit > contrainte:
aj = -1
SASAmax, saDefault = saInit, saInit
print("Surface initiale de {} : {}".format(selection, saInit))
w = W.Weights(len(eigenvectors)) # initialisation des poids (aléatoire)
prgs, d = 0, 0 # d : pas de temps utilisé, prgs : décompte des itérations
SASA = []
while contrainte * aj > saInit * aj and prgs < C.niter: # tant que la contrainte n'est pas satisfaite et que le nombre d'iteration nest pas atteint
w.reajustWeights(prgs) # reajustement des poids
Latm = ReturnDisplacedLatm(
Latm, eigenvectors, natm, d, w.weights,
C) # deplacement des atomes selon les modes pondérés
saInit = calcSASA(
Latm, selection
) # calcul de la surface accessible au solvent après déplacement
if saInit * aj > SASAmax * aj: # si sas init est depasse
w.reajustLimits(
prgs) # reajustement des bornes des poids (entre -1 et 1)
w.saveCombinaisonMax(d) # sauvegarder cette combinaison
SASAmax = saInit
SASA = []
print(
"Etape {}, évolution de la surface accessible au solvant : {:.3f}"
.format(prgs, aj * (saInit - saDefault)))
# retrieveData(prgs,(saInit- saDefault),C,modeE)
modeE += 1
else:
SASA, w = W.watch(saInit, SASA, w)
w.precState(
) # retourne au vecteur de poids précédent si pas d'amélioration
prgs += 1
return [Latm, w]
def goVolume(eigenvectors, Latm, contrainte, C):
"""Lance l'optimisation des poids pour maximiser le volume
-Args:
_eigenvectors: les vecteurs propres selectionés
_Latm: la liste d'atomes
_contrainte: le ratio d'augmentation ou de diminution de la sasa pour la selection
_C: configuration
"""
natm = len(Latm)
axe, h = U.get_axe(C.axis)
U.build_example('./Struct/OBB.pdb', axe,
h) # construit une représentation cubique du volume
R = U.BuildOBB(axe, h) # construit l'objet Volume
volCanali = CalcVolCanal(Latm, R) # calule le volume initial du canal
contrainte = contrainte * volCanali # définition de la contrainte
modeE = 0
aj = 1 # permet d'aller vers une augmentation ou une diminution du volume
if volCanali > contrainte:
aj = -1 # si contrainte est inférieure au volume initial alors on va vers une diminution
volCanalmax, volDefault = volCanali, volCanali
print("Volume initial : {}".format(volCanali))
w = W.Weights(len(eigenvectors)) # initialisation des poids (aléatoire)
d, prgs = 0, 0 # d : pas de temps utilisé, prgs : décompte des itérations
Svol = []
while contrainte * aj > volCanali * aj and prgs < C.niter: # tant que la contrainte n'est pas satisfaite et que le nombre d'iteration nest pas atteint
w.reajustWeights(prgs) # reajustement des poids
Latm = ReturnDisplacedLatm(
Latm, eigenvectors, natm, d, w.weights,
C) # deplacement des atomes selon les modes pondérés
volCanali = CalcVolCanal(
Latm,
R) # calcul de la surface accessible au solvent après déplacement
print(volCanali)
if volCanali * aj > volCanalmax * aj: # si augmentation du volume et post saturation
w.reajustLimits(
prgs) # reajustement des bornes des poids (entre -1 et 1)
w.saveCombinaisonMax(d) # sauvegarder cette combinaison
volCanalmax = volCanali
Svol = []
print("Etape {}, évolution du volume du canal : {:.3f}".format(
prgs, aj * (volCanali - volDefault)))
# retrieveData(prgs,(volCanali-volDefault),C,modeE)
# modeE+=1
else:
Svol, w = W.watch(volCanali, Svol, w)
w.precState(
) # retourne au vecteur de poids précédent si pas d'amélioration
prgs += 1
return [Latm, w]
def __init__(self, zettels):
z_process = process.ZettelPreProcessor()
z_process.init_zettels(zettels)
z_weights = weights.Weights()
self.tags = z_process.given_tags
self.lemma_tokens = z_process.lemmatized_tokens
self.filter_n_grams(z_process.bi_gram, z_weights.n_gram_min_freq, 2)
self.filter_n_grams(z_process.tri_gram, z_weights.n_gram_min_freq, 3)
self.filter_pos()
self.doc_count_dict = self.create_doc_count_dictionary(z_process.create_unique_corpus())
self.window_size = 4
self.score_weights = z_weights.all_score_weights
self.pos_score_switch = z_weights.pos_switch
self.z_area_switch = z_weights.z_area_switch
self.keyword_n = z_weights.keyword_n
self.min_keyword_freq = z_weights.min_keyword_freq
def init(n_dim, domains, dim_names=None):
"""Initializes a conceptual space with the given numer of dimensions and the given set of domains.
'n_dim' is an integer >= 1 and 'domains' is a dictionary from domain ids to sets of dimensions.
The optional argument 'dim_names' contains names for the individual dimensions. Its length must be identical to 'n_dim'.
If it is not given, numbered dimension names are generated."""
if n_dim < 1:
raise Exception("Need at least one dimension")
if not _check_domain_structure(domains, n_dim):
raise Exception("Invalid domain structure")
this._n_dim = n_dim
this._domains = domains
this._concepts = {}
this._concept_colors = {}
# take care of dimension names
if dim_names != None:
if len(dim_names) != n_dim:
raise Exception("Invalid number of dimension names")
else:
this._dim_names = dim_names
else:
this._dim_names = ["dim_{0}".format(i) for i in range(n_dim)]
# construct default weights
dim_weights = {}
dom_weights = {}
for (dom, dims) in domains.items():
dom_weights[dom] = 1.0
local_dim_weights = {}
for dim in dims:
local_dim_weights[dim] = 1
dim_weights[dom] = local_dim_weights
this._no_weights = wghts.Weights(dom_weights, dim_weights)
from http.server import BaseHTTPRequestHandler, HTTPServer import vk from bs4 import BeautifulSoup from requests.exceptions import HTTPError import io import os import time from google.cloud import vision import countries import weights import operator import math weights_photo_tagsD = weights.Weights().getWeightsPhotoTags() weights_groupsD = weights.Weights().getWeightsGroupsD() os.environ["GOOGLE_APPLICATION_CREDENTIALS"]="key.json" session = vk.Session(access_token='') vk_api = vk.API(session, v='5.126', lang='ru', timeout=10) class myHandler(BaseHTTPRequestHandler): def parse_POST(self): ctype, pdict = parse_header(self.headers['content-type']) if ctype == 'multipart/form-data': postvars = parse_multipart(self.rfile, pdict) elif ctype == 'application/x-www-form-urlencoded':
def __init__( self ):
self.g = graph.Graph()
self.w = weights.Weights()
def goDistance(selection, Latm, RatioC, eigenvectors, natm, C):
"""Lance l'optimisation des poids pour maximiser la distance
de la selection selon la contrainte donnée par l'utilisateur
-Args:
_selection: la selection de numéro d'atomes pour lesquel on veut contraindre la distance
sous forme de liste de listes de paires
_Latm: la liste d'atomes
_RatioC: le ratio d'augmentation ou de diminution de la distance moyenne de la selection
_eigenvectors: les vecteurs propres selectionés
_natm:le nombre d'atomes
_C: configuration
"""
distInit = calcDistance(selection, Latm) # calcule la sas de la selection
contrainte = []
for i in range(len(distInit)):
contrainte.append(RatioC * distInit[i]) # définition de la contrainte
# modeE = 0
aj = 1 # permet d'aller vers une augmententation ou diminution la distance
if distInit[0] > contrainte[0]:
aj = -1
Satisfait = False
distmax, distDefault = copy.deepcopy(distInit), copy.deepcopy(distInit)
print("Distance initiale des atomes de la selection {} : {}".format(
selection, distInit))
w = W.Weights(len(eigenvectors)) # initialisation des poids (aléatoire)
prgs, d = 0, 0 # d : pas de temps utilisé, prgs : décompte des itérations
Distances = []
while not Satisfait and prgs < C.niter: # tant que la contrainte n'est pas satisfaite et que le nombre d'iteration nest pas atteint
w.reajustWeights(prgs) # reajustement des poids
Latm = ReturnDisplacedLatmD(
Latm, eigenvectors, natm, d, w.weights,
C) # deplacement des atomes selon les modes pondérés
distInit = calcDistance(
selection, Latm
) # calcul de la surface accessible au solvent après déplacement
progress = True
for i, distance in enumerate(
distInit): # pour chaque distance entre une paire d'atome
if distance * aj < distmax[
i] * aj: # si une des distane ne progresse pas vers la contrainte
progress = False # break
break
if progress: # si tt les distances sont depasse
w.reajustLimits(
prgs) # reajustement des bornes des poids (entre -1 et 1)
w.saveCombinaisonMax(d) # sauvegarder cette combinaison
distmax = copy.deepcopy(distInit)
Distances = []
print("Etape {}, évolution de la distance : {}".format(
prgs, [
aj * (distInit[i] - distDefault[i])
for i in range(len(distInit))
]))
# retrieveData(prgs,(distInit- distDefault),C,modeE)
# modeE+=1
d += 1
if d > 20:
d = 10
else:
Distances, w = W.watch(distInit, Distances, w)
w.precState(
) # retourne au vecteur de poids précédent si pas d'amélioration
# print("Seconds = {:.2f} , {:.2f}, {:.2f}".format((t2-t1),(t3-t2),(((t3-t2)-(t2-t1)))))
Satisfait = True
for i in range(len(distInit)):
if contrainte[i] * aj > distInit[i] * aj:
Satisfait = False
break
prgs += 1
return [Latm, w]
import graph
import weights
g = graph.Graph()
w = weights.Weights()
g.loadFromFile("generatedGraph")
w.loadFromFile("generatedWeights")
# g.printGraph()
g.setWeights(w.getList(), [])
print(g.maxFlow())