def generate_variable(_xmlnode, tag, session, segment):
"""
Process mi and mn tags. Generate variable or number and add it to result string
@return:
"""
#here should be generation of sc-node that represents variable
global last, binoperands, lastop, el
if session == None or segment == None:
return
nodename = _xmlnode.childNodes[0].nodeValue
if not nodename in functions.keys():
parse_result.append(nodename)
if tag != "mi" and tag != "mn":
translation_errors.append("Unknown tag")
return
#start generation
if tag == "mi":
if not nodename in functions.keys():
findElement = sc_utils.getElementByIdtf(nodename, segment)
if findElement == None:
node = session.create_el_idtf(core.Kernel.segment(),
sc.SC_NODE, nodename)[1]
sc_utils.createPair(session, core.Kernel.segment(), el, node,
sc.SC_CONST)
variables_sc[nodename] = node
else:
sc_utils.createPair(session, core.Kernel.segment(), el,
findElement, sc.SC_CONST)
variables_sc[nodename] = findElement
else:
stack.append(nodename)
if tag == "mn":
findElement = sc_utils.getElementByIdtf("Num" + nodename, segment)
if findElement == None:
node = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
"Num" + nodename)[1]
#sc_utils.setContentInt(session, core.Kernel.segment(), node, int(nodename))
sc_utils.createPair(session, core.Kernel.segment(), el, node,
sc.SC_CONST)
variables_sc[nodename] = node
else:
sc_utils.createPair(session, core.Kernel.segment(), el,
findElement, sc.SC_CONST)
variables_sc[nodename] = findElement
variables.append([nodename, last])
if (len(binoperands) == 1):
binoperands.append(variables[-1][0])
operations.append((lastop, binoperands))
binoperands = []
last = []
lastop = ""
return
def genDivideRelation(session, segment, operation, _result):
el1 = math2sc.variables_sc[operation[0]] #divident
el2 = math2sc.variables_sc[operation[1]] #divisor
res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] #difference result node
sc_utils.createPair(session,core.Kernel.segment(), _result, res, sc.SC_CONST)
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, setNode, sc.SC_CONST)
#gen input sum parameters
arc1 = sc_utils.createPair(session,core.Kernel.segment(), setNode, res, sc.SC_CONST)
arc2 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el2, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc1, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc2, sc.SC_CONST)
relation = sc_utils.createPair(session,core.Kernel.segment(), setNode, el1, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relation, sc.SC_CONST)
idtf = "произведение*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
sumNode = sc_utils.getElementByIdtf(idtf, segment)
if sumNode == None:
sumNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, sumNode, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, sumNode, sc.SC_CONST)
relarc = sc_utils.createPair(session,core.Kernel.segment(), sumNode, relation, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relarc, sc.SC_CONST)
return res
def close_sqrt(_xmlnode, tag, session, segment):
"""
Postrprocess msqrt tag
"""
while stack[-1] != "(":
parse_result.append(stack.pop(-1))
if len(stack) == 0:
translation_errors.append(
"Incorrect input string: can't find close bracket")
return
stack.pop(-1)
variables.append(["0.5", []])
findElement = sc_utils.getElementByIdtf("Num0.5", segment)
if findElement == None:
node = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
"Num0.5")[1]
sc_utils.createPair(session, core.Kernel.segment(), el, node,
sc.SC_CONST)
variables_sc["0.5"] = node
else:
sc_utils.createPair(session, core.Kernel.segment(), el, findElement,
sc.SC_CONST)
variables_sc["0.5"] = findElement
parse_result.append("0.5")
parse_result.append("^")
return
def genEqualityRelation(session, segment, operation, _result):
el1 = math2sc.variables_sc[operation[0]]
el2 = math2sc.variables_sc[operation[1]]
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, setNode,
sc.SC_CONST)
arc1 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el1,
sc.SC_CONST)
arc2 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el2,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc1,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc2,
sc.SC_CONST)
idtf = "равенство*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
eqNode = sc_utils.getElementByIdtf(idtf, segment)
if eqNode == None:
eqNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param,
eqNode, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, eqNode,
sc.SC_CONST)
relarc = sc_utils.createPair(session, core.Kernel.segment(), eqNode,
setNode, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relarc,
sc.SC_CONST)
return el1
def close_row(_xmlnode, tag, session, segment):
"""
Postprocess mrow tag
@param _xmlnode:
@param tag:
@param session:
@param segment:
@return:
"""
global rowcount, isroot, isfrac
rowcount -= 1
if rowcount == 0 and isroot == True:
while stack[-1] != "(":
parse_result.append(stack.pop(-1))
if len(stack) == 0:
translation_errors.append(
"Incorrect input string: can't find close bracket")
break
if not isfrac:
parse_result.append("1")
findElement = sc_utils.getElementByIdtf("Num1", segment)
if findElement == None:
node = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
"Num1")[1]
variables_sc["1"] = node
else:
variables_sc["1"] = findElement
isroot = False
return
def gen_fracture_relation(session, segment, operation, _result):
el1 = math2sc.variables_sc[operation[0]]
el2 = math2sc.variables_sc[operation[1]]
#gen node that represents fracture
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, setNode, sc.SC_CONST)
arc1 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el1, sc.SC_CONST)
arc2 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el2, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc1, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc2, sc.SC_CONST)
#find or generate ordinal fracture node
idtf = "обыкновенная дробь"
idtf = sc_utils.utf8ToCp1251(str(idtf))
powNode = sc_utils.getElementByIdtf(idtf, segment)
if powNode == None:
powNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, powNode, sc.SC_CONST)
relarc = sc_utils.createPair(session,core.Kernel.segment(), powNode, setNode, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relarc, sc.SC_CONST)
#find or generate numerator
numIdtf = "числитель_"
numIdtf = sc_utils.utf8ToCp1251(str(numIdtf))
numNode = sc_utils.getElementByIdtf(numIdtf, segment)
if numNode == None:
numNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, numIdtf)[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, numNode, sc.SC_CONST)
a = sc_utils.createPair(session,core.Kernel.segment(), numNode, arc1, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, a, sc.SC_CONST)
#find or generate denominator
numIdtf = "знаменатель_"
numIdtf = sc_utils.utf8ToCp1251(str(numIdtf))
numNode = sc_utils.getElementByIdtf(numIdtf, segment)
if numNode == None:
numNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, numIdtf)[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, numNode, sc.SC_CONST)
a = sc_utils.createPair(session,core.Kernel.segment(), numNode, arc2, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, a, sc.SC_CONST)
return setNode
def genSumRelation(session, segment, operation, _result):
"""
@param session: session
@param segment: list of segments to search objects in
@param operation: sum operation and list of operands
@param _result: a node which the result of translation
@return: a node that represents the result of summ
"""
el1 = math2sc.variables_sc[operation[0]]
el2 = math2sc.variables_sc[operation[1]]
#gen set of sum components
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, setNode,
sc.SC_CONST)
arc1 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el1,
sc.SC_CONST)
arc2 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el2,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc1,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc2,
sc.SC_CONST)
#gen sum relations
res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
"")[1] #add result node
sc_utils.createPair(session, core.Kernel.segment(), _result, res,
sc.SC_CONST)
relation = sc_utils.createPair(session, core.Kernel.segment(), setNode,
res, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relation,
sc.SC_CONST)
idtf = "сумма*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
sumNode = sc_utils.getElementByIdtf(idtf, segment)
if sumNode == None:
sumNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param,
sumNode, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, sumNode,
sc.SC_CONST)
relarc = sc_utils.createPair(session, core.Kernel.segment(), sumNode,
relation, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relarc,
sc.SC_CONST)
return res
def get_sc_element(_segment, _idtf, _object, _sc_type):
"""Generates scs-element, that represent geometry object
@param _segment: segment to work with data in sc-memory
@type _segment: sc_segment
@param _idtf: identificator for search
@type _idtf: str
@param _object: object to create sc-element for
@type _object: Object
@param _sc_type: sc-type for element
@type _sc_type: sc_type
@return: addr of create sc-element
@rtype: sc_global_addr
"""
session = core.Kernel.session()
# getting node idtf
sc_object = None
el = None
isUri = False
# if idtf empty, then creating new element
if _idtf is None:
el = session.create_el(_segment, _sc_type)
else:
# check if idtf if full uri
isUri = _idtf.startswith('/')
# trying to find object by idtf, if it doesn't exists, then creating it
try:
if el is None:
if isUri:
el = session.find_el_full_uri(_idtf)
if el is None:
el = session.create_el_full_uri(_idtf, _sc_type)[1]
else:
_segs = [_segment.get_full_uri()]
_segs.extend(env.search_segments)
# trying to find element
el = sc_utils.getElementByIdtf(_idtf, _segs)
if el is None:
el = session.create_el_idtf(_segment, _sc_type, _idtf)[1]
except:
import sys, traceback
print sys.exc_info()[0]
traceback.print_exc(file=sys.stdout)
return None
_object._setScAddr(el)
return el
def get_sc_element(_segment, _idtf, _object, _sc_type):
"""Generates scs-element, that represent geometry object
@param _segment: segment to work with data in sc-memory
@type _segment: sc_segment
@param _idtf: identificator for search
@type _idtf: str
@param _object: object to create sc-element for
@type _object: Object
@param _sc_type: sc-type for element
@type _sc_type: sc_type
@return: addr of create sc-element
@rtype: sc_global_addr
"""
session = core.Kernel.session()
# getting node idtf
sc_object = None
el = None
isUri = False
# if idtf empty, then creating new element
if _idtf is None:
el = session.create_el(_segment, _sc_type)
else:
# check if idtf if full uri
isUri = _idtf.startswith('/')
# trying to find object by idtf, if it doesn't exists, then creating it
try:
if el is None:
if isUri:
el = session.find_el_full_uri(_idtf)
if el is None:
el = session.create_el_full_uri(_idtf, _sc_type)[1]
else:
_segs = [_segment.get_full_uri()]
_segs.extend(env.search_segments)
# trying to find element
el = sc_utils.getElementByIdtf(_idtf, _segs)
if el is None:
el = session.create_el_idtf(_segment, _sc_type, _idtf)[1]
except:
import sys, traceback
print sys.exc_info()[0]
traceback.print_exc(file=sys.stdout)
return None
_object._setScAddr(el)
return el
def gen_function(name, params, session, segment, _result):
"""
@param name: function name
@param params: list of function params
@param _result: an output node of the translator
@return:
"""
#gen function node
idtf = name + "*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
funcNode = sc_utils.getElementByIdtf(idtf, segment)
if funcNode == None:
funcNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param,
funcNode, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, funcNode,
sc.SC_CONST)
#gen args set
argsSet = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, argsSet,
sc.SC_CONST)
for x in params:
param = math2sc.variables_sc[x]
arc = sc_utils.createPair(session, core.Kernel.segment(), argsSet,
param, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, param,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc,
sc.SC_CONST)
pass
#gen relation arc
result = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
relation = sc_utils.createPair(session, core.Kernel.segment(), argsSet,
result, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relation,
sc.SC_CONST)
arc = sc_utils.createPair(session, core.Kernel.segment(), funcNode,
relation, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc,
sc.SC_CONST)
return result
def genMultiplyRelation(session, segment, operation, _result):
el1 = math2sc.variables_sc[operation[0]]
el2 = math2sc.variables_sc[operation[1]]
#gen set of sum components
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, setNode,
sc.SC_CONST)
arc1 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el1,
sc.SC_CONST)
arc2 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el2,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc1,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc2,
sc.SC_CONST)
#gen sum relations
res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
"")[1] #add result node
sc_utils.createPair(session, core.Kernel.segment(), _result, res,
sc.SC_CONST)
relation = sc_utils.createPair(session, core.Kernel.segment(), setNode,
res, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relation,
sc.SC_CONST)
idtf = "произведение*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
sumNode = sc_utils.getElementByIdtf(idtf, segment)
if sumNode == None:
sumNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param,
sumNode, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, sumNode,
sc.SC_CONST)
relarc = sc_utils.createPair(session, core.Kernel.segment(), sumNode,
relation, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relarc,
sc.SC_CONST)
return res
def genDifferenceRelation(session, segment, operation, _result):
el1 = math2sc.variables_sc[operation[0]] #minuend
el2 = math2sc.variables_sc[operation[1]] #subtrahend
res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
"")[1] #difference result node
sc_utils.createPair(session, core.Kernel.segment(), _result, res,
sc.SC_CONST)
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, setNode,
sc.SC_CONST)
#gen input sum parameters
arc1 = sc_utils.createPair(session, core.Kernel.segment(), setNode, res,
sc.SC_CONST)
arc2 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el2,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc1,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc2,
sc.SC_CONST)
relation = sc_utils.createPair(session, core.Kernel.segment(), setNode,
el1, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relation,
sc.SC_CONST)
idtf = "сумма*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
sumNode = sc_utils.getElementByIdtf(idtf, segment)
if sumNode == None:
sumNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param,
sumNode, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, sumNode,
sc.SC_CONST)
relarc = sc_utils.createPair(session, core.Kernel.segment(), sumNode,
relation, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relarc,
sc.SC_CONST)
return res
def genSumRelation(session, segment, operation, _result):
"""
@param session: session
@param segment: list of segments to search objects in
@param operation: sum operation and list of operands
@param _result: a node which the result of translation
@return: a node that represents the result of summ
"""
el1 = math2sc.variables_sc[operation[0]]
el2 = math2sc.variables_sc[operation[1]]
#gen set of sum components
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, setNode, sc.SC_CONST)
arc1 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el1, sc.SC_CONST)
arc2 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el2, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc1, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc2, sc.SC_CONST)
#gen sum relations
res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] #add result node
sc_utils.createPair(session,core.Kernel.segment(), _result, res, sc.SC_CONST)
relation = sc_utils.createPair(session,core.Kernel.segment(), setNode, res, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relation, sc.SC_CONST)
idtf = "сумма*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
sumNode = sc_utils.getElementByIdtf(idtf, segment)
if sumNode == None:
sumNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, sumNode, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, sumNode, sc.SC_CONST)
relarc = sc_utils.createPair(session,core.Kernel.segment(), sumNode, relation, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relarc, sc.SC_CONST)
return res
def gen_function(name, params, session, segment, _result):
"""
@param name: function name
@param params: list of function params
@param _result: an output node of the translator
@return:
"""
#gen function node
idtf = name+"*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
funcNode = sc_utils.getElementByIdtf(idtf, segment)
if funcNode == None:
funcNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, funcNode, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, funcNode, sc.SC_CONST)
#gen args set
argsSet = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, argsSet, sc.SC_CONST)
for x in params:
param = math2sc.variables_sc[x]
arc = sc_utils.createPair(session, core.Kernel.segment(), argsSet, param, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, param, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc, sc.SC_CONST)
pass
#gen relation arc
result = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
relation = sc_utils.createPair(session, core.Kernel.segment(), argsSet, result, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relation, sc.SC_CONST)
arc = sc_utils.createPair(session,core.Kernel.segment(), funcNode, relation, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc, sc.SC_CONST)
return result
def genEqualityRelation(session, segment, operation, _result):
el1 = math2sc.variables_sc[operation[0]]
el2 = math2sc.variables_sc[operation[1]]
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, setNode, sc.SC_CONST)
arc1 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el1, sc.SC_CONST)
arc2 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el2, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc1, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc2, sc.SC_CONST)
idtf = "равенство*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
eqNode = sc_utils.getElementByIdtf(idtf, segment)
if eqNode == None:
eqNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, eqNode, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, eqNode, sc.SC_CONST)
relarc = sc_utils.createPair(session,core.Kernel.segment(), eqNode, setNode, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relarc, sc.SC_CONST)
return el1
def translate_impl(self, _input, _output):
"""Translator implementation
"""
errors = []
objs = objects.ScObject._sc2Objects(_input)
assert len(objs) > 0
sheet = objs[0]
assert isinstance(sheet, objects.ObjectSheet)
seg = sheet.getTmpSegment()
import suit.core.sc_utils as sc_utils
errors = []
session = core.Kernel.session()
# getting data and translate to sc
field = sheet.getLogic().field
print field
# remove old objects
for layer in field.layers:
for item in layer.items:
_addr = item._getScAddr()
if _addr is not None:
if _addr.seg.this == seg.this:
item._setScAddr(None)
session.erase_el(_addr)
classifier = field.classifier
_segs = [seg.get_full_uri()]
_segs.extend(env.search_segments)
for layer in field.layers:
for item in layer.items:
# if (not item.type in classifier.TYPES_TOWN):
# continue
# creating node in sc-memory
_addr = sc_utils.createNodeElement(session, seg, sc.SC_CONST)
item._setScAddr(_addr)
if (item.type in classifier.TYPES_TOWN):
sc_utils.createPairPosPerm(session, seg,
map_keynodes.ObjectType.town,
_addr, sc.SC_CONST)
elif (item.type in classifier.TYPES_RAILWAY):
sc_utils.createPairPosPerm(session, seg,
map_keynodes.ObjectType.railway,
_addr, sc.SC_CONST)
elif item.type == classifier.TYPE_DISTRICT:
sc_utils.createPairPosPerm(
session, seg, map_keynodes.ObjectType.district, _addr,
sc.SC_CONST)
elif item.type == classifier.TYPE_AREA:
sc_utils.createPairPosPerm(session, seg,
map_keynodes.ObjectType.area,
_addr, sc.SC_CONST)
elif item.type in classifier.TYPES_ROAD:
sc_utils.createPairPosPerm(session, seg,
map_keynodes.ObjectType.road,
_addr, sc.SC_CONST)
for atribute in item.attributes:
if ((atribute in classifier.atributes)
and (item.attributes[atribute] != "")):
_atr = sc_utils.getElementByIdtf(
classifier.atributes[atribute], _segs)
if _atr is None:
_atr = sc_utils.createNodeRoleRelation(
session, seg, sc.SC_CONST)
session.set_idtf(_atr,
classifier.atributes[atribute])
_val = sc_utils.getElementByIdtf(
item.attributes[atribute], _segs)
if _val is None:
_val = sc_utils.createNodeElement(
session, seg, sc.SC_CONST)
session.set_idtf(_val, item.attributes[atribute])
#print classifier.atributes[atribute], item.attributes[atribute]
pair = sc_utils.createPairPosPerm(
session, seg, _addr, _val, sc.SC_CONST)
sc_utils.createPairPosPerm(session, seg, _atr, pair,
sc.SC_CONST)
return errors
def translate_impl(self, _input, _output):
"""Translator implementation
@param _input: input data set
@type _input: sc_global_addr
@param _output: output window (must be created)
@type _output: sc_global_addr
@return: list of errors each element of list is a tuple(object, error)
@rtype: list
"""
segment = core.Kernel.segment()
session = core.Kernel.session()
_segs = [segment.get_full_uri()]
search_segments = [
"/ui/core",
"/seb/belarus",
"/seb/planimetry",
"/seb/graph",
"/seb/rus",
"/etc/questions",
"/etc/com_keynodes",
"/seb/test",
"/proc/agents/nsm/keynode",
]
_segs.extend(search_segments)
el = sc_utils.getElementByIdtf("test2_scs_sc", _segs)
if el == None:
return
errors = []
objs = objects.ScObject._sc2Objects(_output)
assert len(objs) > 0
sheet = objs[0]
assert type(sheet) is objects.ObjectSheet
session = core.Kernel.session()
trans_objs = []
result_objs = []
# creating list of element to translate
it = session.create_iterator(
session.sc_constraint_new(sc_constants.CONSTR_3_f_a_a, sc.SC_A_CONST | sc.SC_POS, sc.SC_NODE), True
)
list_of_addrs = []
while not it.is_over():
trans_objs.append(it.value(2))
list_of_addrs.append(str(it.value(2).this))
it.next()
# getting objects on sheet
childs = sheet.getChilds()
sc_scs = {}
object_types = {}
for obj in childs:
addr = obj._getScAddr()
if addr is not None:
s_addr = str(addr.this)
sc_scs[s_addr] = obj
object_types[s_addr] = session.get_type(addr)
list_of_addrs.append(s_addr)
ignore_list = []
process_pairs = []
# translating binary and noorient pairs and store types
for obj in trans_objs:
_type = session.get_type(obj)
object_types[str(obj.this)] = _type
if str(obj.this) in ignore_list:
continue
# something miss
# translating objects
for obj in trans_objs:
if sc_scs.has_key(str(obj.this)) or (str(obj.this) in ignore_list):
continue
_type = object_types[str(obj.this)]
# checking pairs
if _type & sc.SC_ARC:
beg = session.get_beg(obj)
end = session.get_end(obj)
if (beg is not None) and (end is not None):
if (str(beg.this) in list_of_addrs) and (str(end.this) in list_of_addrs):
process_pairs.append((obj, beg, end))
else:
continue # skipping dead (haven't begin or end element) pairs
# translating sc-element to scg-object
scs_obj = translate_obj(session, obj, object_types[str(obj.this)])
sc_scs[str(obj.this)] = scs_obj
# translating identificators
# idtf = session.get_idtf(obj)
# if not sc_utils.isSystemId(idtf):
# scg_obj.setText(idtf)
# scg_obj.setWasInMemory(True)
# adding to window
# sheet.addChild(scg_obj)
result_objs.append(scs_obj)
def gen_fracture_relation(session, segment, operation, _result):
el1 = math2sc.variables_sc[operation[0]]
el2 = math2sc.variables_sc[operation[1]]
#gen node that represents fracture
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, setNode,
sc.SC_CONST)
arc1 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el1,
sc.SC_CONST)
arc2 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el2,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc1,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc2,
sc.SC_CONST)
#find or generate ordinal fracture node
idtf = "обыкновенная дробь"
idtf = sc_utils.utf8ToCp1251(str(idtf))
powNode = sc_utils.getElementByIdtf(idtf, segment)
if powNode == None:
powNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
idtf)[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, powNode,
sc.SC_CONST)
relarc = sc_utils.createPair(session, core.Kernel.segment(), powNode,
setNode, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relarc,
sc.SC_CONST)
#find or generate numerator
numIdtf = "числитель_"
numIdtf = sc_utils.utf8ToCp1251(str(numIdtf))
numNode = sc_utils.getElementByIdtf(numIdtf, segment)
if numNode == None:
numNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
numIdtf)[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, numNode,
sc.SC_CONST)
a = sc_utils.createPair(session, core.Kernel.segment(), numNode, arc1,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, a,
sc.SC_CONST)
#find or generate denominator
numIdtf = "знаменатель_"
numIdtf = sc_utils.utf8ToCp1251(str(numIdtf))
numNode = sc_utils.getElementByIdtf(numIdtf, segment)
if numNode == None:
numNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
numIdtf)[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, numNode,
sc.SC_CONST)
a = sc_utils.createPair(session, core.Kernel.segment(), numNode, arc2,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, a,
sc.SC_CONST)
return setNode
def translate_object(_segment, _object, _type, _params):
"""Translates specified scg-object to SC-code.
@param _segment: segment to translate object in
@type _segment: sc_segment
@param _object: scg-object to translate
@type _object: SCgObject or SCgPair
@param _type: object type
@type _type: sc_type
@param _params: additional parameters to translate object. It contains list of sc-elements, that
designates semantic types for specified object. sc-element, that designate translated object will be included to
sets from _params
@type _params: list
@return: if object translated successfully, then return True, else - False
@rtype: bool
"""
import suit.core.sc_utils as sc_utils
session = core.Kernel.session()
# getting node idtf
idtf = _object.getText()
sc_object = None
el = None
isUri = False
created = False
# if idtf empty, then creating new element
if idtf is None:
el = session.create_el(_segment, _type)
created = True
else:
# encode idtf to cp1251
idtf = sc_utils.utf8ToCp1251(str(idtf))
# check if idtf if full uri
isUri = idtf.startswith('/')
# trying to find object by idtf, if it doesn't exists, then creating it
try:
if el is None:
if isUri:
el = session.find_el_full_uri(idtf)
if el is None:
el = session.create_el_full_uri(idtf, _type)[1]
created = True
else:
_segs = [_segment.get_full_uri()]
_segs.extend(env.search_segments)
# trying to find element
el = sc_utils.getElementByIdtf(idtf, _segs)
if el is None:
el = session.create_el_idtf(_segment, _type, idtf)[1]
created = True
except:
import sys, traceback
print sys.exc_info()[0]
traceback.print_exc(file=sys.stdout)
return False
assert el is not None
_object._setScAddr(el)
_object.setMerged(not created)
# including to sets for structure type
for param in _params:
sc_utils.createPairPosPerm(session, _segment, param, el, sc.SC_CONST)
return True
def genPowerRelation(session, segment, operation, _result):
el1 = math2sc.variables_sc[operation[0]]
el2 = math2sc.variables_sc[operation[1]]
#gen set of sum components
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, setNode,
sc.SC_CONST)
arc1 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el1,
sc.SC_CONST)
arc2 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el2,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc1,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc2,
sc.SC_CONST)
#gen sum relations
res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
"")[1] #add result node
sc_utils.createPair(session, core.Kernel.segment(), _result, res,
sc.SC_CONST)
relation = sc_utils.createPair(session, core.Kernel.segment(), setNode,
res, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relation,
sc.SC_CONST)
idtf = "возведение в степень*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
powNode = sc_utils.getElementByIdtf(idtf, segment)
if powNode == None:
powNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param,
powNode, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, powNode,
sc.SC_CONST)
relarc = sc_utils.createPair(session, core.Kernel.segment(), powNode,
setNode, sc.SC_CONST)
baseIdtf = "основание_"
baseIdtf = sc_utils.utf8ToCp1251(str(baseIdtf))
baseNode = sc_utils.getElementByIdtf(baseIdtf, segment)
if baseNode == None:
baseNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
baseIdtf)[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, baseNode,
sc.SC_CONST)
a = sc_utils.createPair(session, core.Kernel.segment(), baseNode, arc1,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, a,
sc.SC_CONST)
expIdtf = "показатель_"
expIdtf = sc_utils.utf8ToCp1251(str(expIdtf))
expNode = sc_utils.getElementByIdtf(expIdtf, segment)
if expNode == None:
expNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
expIdtf)[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, expNode,
sc.SC_CONST)
a = sc_utils.createPair(session, core.Kernel.segment(), expNode, arc2,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, a,
sc.SC_CONST)
powerIdtf = "результат_"
powerIdtf = sc_utils.utf8ToCp1251(str(powerIdtf))
powerNode = sc_utils.getElementByIdtf(powerIdtf, segment)
if powerNode == None:
powerNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
powerIdtf)[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, powerNode,
sc.SC_CONST)
a = sc_utils.createPair(session, core.Kernel.segment(), powerNode,
relation, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, a,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relarc,
sc.SC_CONST)
return res
def translate_object(_segment, _object, _type, _params):
"""Translates specified scg-object to SC-code.
@param _segment: segment to translate object in
@type _segment: sc_segment
@param _object: scg-object to translate
@type _object: SCgObject or SCgPair
@param _type: object type
@type _type: sc_type
@param _params: additional parameters to translate object. It contains list of sc-elements, that
designates semantic types for specified object. sc-element, that designate translated object will be included to
sets from _params
@type _params: list
@return: if object translated successfully, then return True, else - False
@rtype: bool
"""
import suit.core.sc_utils as sc_utils
session = core.Kernel.session()
# getting node idtf
idtf = _object.getText()
sc_object = None
el = None
isUri = False
created = False
# if idtf empty, then creating new element
if idtf is None:
el = session.create_el(_segment, _type)
created = True
else:
# encode idtf to cp1251
idtf = sc_utils.utf8ToCp1251(str(idtf))
# check if idtf if full uri
isUri = idtf.startswith('/')
# trying to find object by idtf, if it doesn't exists, then creating it
try:
if el is None:
if isUri:
el = session.find_el_full_uri(idtf)
if el is None:
el = session.create_el_full_uri(idtf, _type)[1]
created = True
else:
_segs = [_segment.get_full_uri()]
_segs.extend(env.search_segments)
# trying to find element
el = sc_utils.getElementByIdtf(idtf, _segs)
if el is None:
el = session.create_el_idtf(_segment, _type, idtf)[1]
created = True
except:
import sys, traceback
print sys.exc_info()[0]
traceback.print_exc(file=sys.stdout)
return False
assert el is not None
_object._setScAddr(el)
_object.setMerged(not created)
# including to sets for structure type
for param in _params:
sc_utils.createPairPosPerm(session, _segment, param, el, sc.SC_CONST)
return True
def translate_impl(self, _input, _output):
"""Translator implementation
"""
errors = []
objs = objects.ScObject._sc2Objects(_input)
assert len(objs) > 0
sheet = objs[0]
assert isinstance(sheet, objects.ObjectSheet)
seg = sheet.getTmpSegment()
import suit.core.sc_utils as sc_utils
errors = []
session = core.Kernel.session()
# getting data and translate to sc
field = sheet.getLogic().field
print field
# remove old objects
for layer in field.layers:
for item in layer.items:
_addr = item._getScAddr()
if _addr is not None:
if _addr.seg.this == seg.this:
item._setScAddr(None)
session.erase_el(_addr)
classifier = field.classifier
_segs = [seg.get_full_uri()]
_segs.extend(env.search_segments)
for layer in field.layers:
for item in layer.items:
# if (not item.type in classifier.TYPES_TOWN):
# continue
# creating node in sc-memory
_addr = sc_utils.createNodeElement(session, seg, sc.SC_CONST)
item._setScAddr(_addr)
if (item.type in classifier.TYPES_TOWN):
sc_utils.createPairPosPerm(session, seg, map_keynodes.ObjectType.town, _addr, sc.SC_CONST)
elif (item.type in classifier.TYPES_RAILWAY):
sc_utils.createPairPosPerm(session, seg, map_keynodes.ObjectType.railway, _addr, sc.SC_CONST)
elif item.type == classifier.TYPE_DISTRICT:
sc_utils.createPairPosPerm(session, seg, map_keynodes.ObjectType.district, _addr, sc.SC_CONST)
elif item.type == classifier.TYPE_AREA:
sc_utils.createPairPosPerm(session, seg, map_keynodes.ObjectType.area, _addr, sc.SC_CONST)
elif item.type in classifier.TYPES_ROAD:
sc_utils.createPairPosPerm(session, seg, map_keynodes.ObjectType.road, _addr, sc.SC_CONST)
for atribute in item.attributes:
if ((atribute in classifier.atributes) and (item.attributes[atribute]!="")):
_atr=sc_utils.getElementByIdtf(classifier.atributes[atribute], _segs)
if _atr is None:
_atr = sc_utils.createNodeRoleRelation(session, seg, sc.SC_CONST)
session.set_idtf(_atr, classifier.atributes[atribute])
_val=sc_utils.getElementByIdtf(item.attributes[atribute], _segs)
if _val is None:
_val = sc_utils.createNodeElement(session, seg, sc.SC_CONST)
session.set_idtf(_val, item.attributes[atribute])
#print classifier.atributes[atribute], item.attributes[atribute]
pair = sc_utils.createPairPosPerm(session, seg, _addr, _val, sc.SC_CONST)
sc_utils.createPairPosPerm(session, seg, _atr, pair, sc.SC_CONST)
return errors
def generate_exppressions(_xmlnode, tag, session, segment):
"""
Process math tag. Generate relations between variables and numbers
"""
global parse_result
while len(stack) > 0:
parse_result.append(stack.pop(-1))
#generate unary expressions
for var in variables:
varname = var[0]
while len(var[1]) > 0:
op = var[1].pop(0)
expr = op + var[0]
key = var[0]
var[0] = expr
for operation in operations:
for arg in operation[1]:
if arg == key:
operation[1][operation[1].index(key)] = expr
for elem in parse_result:
if elem == key:
parse_result[parse_result.index(key)] = expr
if op == "-":
#generate unary minus relation
#find unary minus relation node, if not find create
idtf = "обратное число*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
unMinusNode = sc_utils.getElementByIdtf(idtf, segment)
if unMinusNode == None:
unMinusNode = session.create_el_idtf(
core.Kernel.segment(), sc.SC_NODE, idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session,
core.Kernel.segment(),
param, unMinusNode,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), el,
unMinusNode, sc.SC_CONST)
#gen node for result
varSC = variables_sc[key]
res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
"")[1] #node for result
pair = sc_utils.createPair(
session, core.Kernel.segment(), varSC, res,
sc.SC_CONST) #arc between processed node and result
relBelong = sc_utils.createPair(session, core.Kernel.segment(),
unMinusNode, pair, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), el, res,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), el, pair,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), el,
relBelong, sc.SC_CONST)
variables_sc[expr] = res
#generate operations
expr = ""
for elem in parse_result:
if (not elem in operation_priority.keys()
and not elem in functions.keys()):
stack.append(elem)
else:
op = elem
if (op not in functions.keys()):
operand1 = stack.pop(-1)
operand2 = stack.pop(-1)
expr = operand2 + op + operand1
stack.append(expr)
if op in binary_expression_gen.keys():
gen_operation = binary_expression_gen[op]
res = gen_operation(session, segment, [operand2, operand1],
el)
variables_sc[expr] = res
else:
translation_errors.append("Unsupported operation")
else:
operands = []
expr = op + "("
for i in range(0, functions[op], 1):
operands.append(stack.pop(-1))
expr += operands[-1]
expr += ","
expr += ")"
stack.append(expr)
res = f_generator.gen_function(op, operands, session, segment,
el)
variables_sc[expr] = res
return
def genPowerRelation(session, segment, operation, _result):
el1 = math2sc.variables_sc[operation[0]]
el2 = math2sc.variables_sc[operation[1]]
#gen set of sum components
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, setNode, sc.SC_CONST)
arc1 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el1, sc.SC_CONST)
arc2 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el2, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc1, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc2, sc.SC_CONST)
#gen sum relations
res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] #add result node
sc_utils.createPair(session,core.Kernel.segment(), _result, res, sc.SC_CONST)
relation = sc_utils.createPair(session,core.Kernel.segment(), setNode, res, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relation, sc.SC_CONST)
idtf = "возведение в степень*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
powNode = sc_utils.getElementByIdtf(idtf, segment)
if powNode == None:
powNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, powNode, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, powNode, sc.SC_CONST)
relarc = sc_utils.createPair(session,core.Kernel.segment(), powNode, setNode, sc.SC_CONST)
baseIdtf = "основание_"
baseIdtf = sc_utils.utf8ToCp1251(str(baseIdtf))
baseNode = sc_utils.getElementByIdtf(baseIdtf, segment)
if baseNode == None:
baseNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, baseIdtf)[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, baseNode, sc.SC_CONST)
a = sc_utils.createPair(session,core.Kernel.segment(), baseNode, arc1, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, a, sc.SC_CONST)
expIdtf = "показатель_"
expIdtf = sc_utils.utf8ToCp1251(str(expIdtf))
expNode = sc_utils.getElementByIdtf(expIdtf, segment)
if expNode == None:
expNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, expIdtf)[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, expNode, sc.SC_CONST)
a = sc_utils.createPair(session,core.Kernel.segment(), expNode, arc2, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, a, sc.SC_CONST)
powerIdtf = "результат_"
powerIdtf = sc_utils.utf8ToCp1251(str(powerIdtf))
powerNode = sc_utils.getElementByIdtf(powerIdtf, segment)
if powerNode == None:
powerNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, powerIdtf)[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, powerNode, sc.SC_CONST)
a = sc_utils.createPair(session,core.Kernel.segment(), powerNode, relation, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, a, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relarc, sc.SC_CONST)
return res
