def __init__(self,
dataset,
learning_rate=0.01,
n_iter=10000,
momentum=0.9,
shutdown_condition=0.01):
self.n_iter = n_iter
self.dataset = dataset
self.learning_rate = learning_rate
self.x = dataset.train_x
self.Y = dataset.train_Y
self.shutdown_condition = shutdown_condition
self.cost = []
self.momentum = momentum
self.setup()
self.diagram = Diagram(self)
def __init__(self,
img_osm,
bigger_side_blocks_count,
sectors_count,
with_fast=True,
with_angle_penalty=False):
"""
img_osm - структура объектов на изображении (см utils)
bigger_size_blocks_count - количество элементов сетки на большей стороне изображения
with_fast - использовать ли быструю версию построения и сравнения диаграмм
with_angle_penalty - учитывать ли видимые угловые размеры объекта при рассчёте штрафа
"""
self.sectors_count = sectors_count
self.with_angle_penalty = with_angle_penalty
# Дальше нужно понять, сколько будет блоков всего на изображении, и где будут находиться центры этих блоков (сетки)
self.center_points = calculate_blocks_centers(
img_osm.img_cutted_shape, bigger_side_blocks_count)
# Теперь для каждой из центральных точек нужно построить круговую диаграмму
self.circle_diagrams = []
if with_fast:
self.fast_diagrams = []
for center_p in self.center_points:
circle_diagram = create_circle_diagram(self.sectors_count,
center_p, img_osm,
self.with_angle_penalty)
self.circle_diagrams.append(circle_diagram)
if with_fast:
self.fast_diagrams.append(Diagram(circle_diagram.sectors))
def __init__(self, diagram_or_container):
'''
diagram_or_container is either Diagram or Container, if container, then Diagram is internally created
'''
# make sure we have diagram
if isinstance(diagram_or_container, Diagram):
self.diagram = diagram_or_container
elif isinstance(diagram_or_container, Container):
# make new diagram
self.diagram = Diagram(diagram_or_container)
else:
raise TypeError(
"AlphaShape.__init__(): Diagram or Container required but something else given"
)
# do rest of the initialization
self._diagram_handle = self.diagram._diagram_handle
# create item on the C++ side
self._shape_handle = dmga2py.new_sasa_shape(self._diagram_handle)
def __init__(self, fileName='', parent=None):
super(MainPseWindow, self).__init__(parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
layout = QHBoxLayout() # horizontal box layout
self.view = MyQGraphicsView(self)
self.diagram = Diagram(self) # Diagram is QGraphicsScene
self.view.setScene(self.diagram) # set scene to the view
self.view.setSceneRect(QRectF(-2000, -2000, 4000, 4000))
self.view.centerOn(QPointF(0, 0)) # pociatocna poloha
# vyvolanie mouseMoveEvent pri kazdom pohybe mysi
self.view.setMouseTracking(True)
# self.view.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
layout.addWidget(self.view)
self.widget = QWidget()
self.widget.setLayout(layout)
self.widget.setContextMenuPolicy(Qt.CustomContextMenu)
self.setCentralWidget(self.widget)
self.widget.customContextMenuRequested.connect(self.createContextMenu)
self.fileName = fileName # inicializacia diagramu pri zadanom mene diagramu
if self.fileName == '':
self.setWindowTitle('Untitled.pse')
else:
self.diagram.diagramLoad(self.fileName)
self.setWindowTitle(self.fileName)
self.setWindowIcon(QIcon('./icons/ikona_pse_128x128.png'))
self.simEngine = None
self.recentFileActs = []
self.init_recent_files()
self.setStatusBar(QStatusBar(self))
self.lib_win = None # Liblary window
def __call__(self, screen):
widget = Diagram(name=screen.name,
model=screen.model,
view=screen.view,
ids=((screen.id or []) and [screen.id])
or screen.ids[:1],
domain=screen.domain,
context=screen.context)
if not screen.id:
screen.id = screen.ids[0]
return widget
def main():
_type = '' #Тип лексемы
#Ввод файла в программу
original_file = open('input1.txt')
text_file = original_file.read(MAX_TEXT)
text_file = text_file + '\0' #добавим концевой ноль в конец исходного файла
print(text_file)
original_file.close()
scaner = Scaner(text_file) #Инициализация сканера
print("\nScaner: ")
#Вывод всех лексем (реализация сканера)
while _type != END:
_type = scaner.scan()
print('%-10s' % (FOR_PRINT[_type]), '-->\t', ''.join(scaner.get_lex()))
# Синтаксический анализатор
dg = Diagram(text_file)
dg.S()
print('\nTree: ')
dg.printTree()
def get_model(self):
named_pt_assn, named_line_assn, named_circ_assn, segments, \
unnamed_points, unnamed_lines, unnamed_circles_assn, ndgs, goals = self.run([
self.name2pt, self.name2line, self.name2circ,
self.segments, self.unnamed_points, self.unnamed_lines, self.unnamed_circles,
self.ndgs, self.goals
])
return Diagram(named_points=named_pt_assn,
named_lines=named_line_assn,
named_circles=named_circ_assn,
segments=segments,
seg_colors=self.seg_colors,
unnamed_points=unnamed_points,
unnamed_lines=unnamed_lines,
unnamed_circles=unnamed_circles_assn,
ndgs=ndgs,
goals=goals)
def generateDataset(self, diagramNumber, outputPath, outputhFileRecord):
self.images_list = []
for i in range(1, diagramNumber + 1):
diagram = Diagram('diagram' + str(i) + '.jpg',
self.originProperties)
diagram.generateImage()
diagram.save(outputPath)
self.images_list = self.images_list + diagram.images_list
self.saveCsv(os.path.join(outputPath, 'annotations.csv'))
createTFRecord(outputhFileRecord, outputPath,
os.path.join(outputPath, 'annotations.csv'),
self.originProperties)
is an implemenation of a diagram plotter that can either draw curves or plot
data according to a two-dimensional list.
"""
from diagram import Diagram
from CSVParser import CSVParser
# Demo for Bars
csv_data_bars = []
csv_parser = CSVParser(strip_spaces=True,
strip_inner_spaces=True,
use_heading=True,
use_labels=True)
csv_parser.data_type = float
csv_parser.load_from_csv('population.csv')
csv_data = csv_parser.rows
diagram_bars = Diagram(type='bars', data=csv_data)
diagram_bars.show()
# Demo for Piechart
csv_parser = CSVParser(strip_spaces=True,
strip_inner_spaces=True,
use_heading=True,
use_labels=True)
csv_parser.data_type = float
csv_parser.load_from_csv('population.csv')
csv_data_piechart = csv_parser.rows
diagram_piechart = Diagram(type='piechart', data=csv_data_piechart)
diagram_piechart.show()
# Demo for Histogram
csv_parser = CSVParser(strip_spaces=True,
class MainPseWindow(QMainWindow):
'''
@if English
Main application window.
@endif
@if Slovak
Hlavne okno aplikacie.
Ovladacie klavesy a skratky editora diagramov.
ESC - Cancel action
DEL - Delete selected component or net
C - Copy component
M - Move
N - Add net
R - Rotate right
L - Rotate left
CTRL+1 Start simulatora / generatora
CTRL+2 Stop simulatora
CTRL+3 Stop simulatora a reset komponentov
@endif
'''
def __init__(self, fileName='', parent=None):
super(MainPseWindow, self).__init__(parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
layout = QHBoxLayout() # horizontal box layout
self.view = MyQGraphicsView(self)
self.diagram = Diagram(self) # Diagram is QGraphicsScene
self.view.setScene(self.diagram) # set scene to the view
self.view.setSceneRect(QRectF(-2000, -2000, 4000, 4000))
self.view.centerOn(QPointF(0, 0)) # pociatocna poloha
# vyvolanie mouseMoveEvent pri kazdom pohybe mysi
self.view.setMouseTracking(True)
# self.view.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
layout.addWidget(self.view)
self.widget = QWidget()
self.widget.setLayout(layout)
self.widget.setContextMenuPolicy(Qt.CustomContextMenu)
self.setCentralWidget(self.widget)
self.widget.customContextMenuRequested.connect(self.createContextMenu)
self.fileName = fileName # inicializacia diagramu pri zadanom mene diagramu
if self.fileName == '':
self.setWindowTitle('Untitled.pse')
else:
self.diagram.diagramLoad(self.fileName)
self.setWindowTitle(self.fileName)
self.setWindowIcon(QIcon('./icons/ikona_pse_128x128.png'))
self.simEngine = None
self.recentFileActs = []
self.init_recent_files()
self.setStatusBar(QStatusBar(self))
self.lib_win = None # Liblary window
def createContextMenu(self):
'''create and show context menu for component'''
menu = QMenu(self)
menu.addAction(self.ui.ActionEditComponent)
menu.addSeparator()
menu.addAction(self.ui.ActionRotateLeftComponent)
menu.addAction(self.ui.ActionRotateRightComponent)
menu.addSeparator()
menu.addAction(self.ui.ActionFlipHorizontalComponent)
menu.addAction(self.ui.ActionFlipVerticalComponent)
menu.exec_(QCursor.pos())
def _setGridAction(self, action):
'''set diagram grid according to action data'''
grid_type = action.data()
self.diagram.setGrid(grid_type) # hide
def _snapGrid(self, checked):
'''set/unset snapping on the grid, according action button'''
self.diagram.snapOnGrid = checked
def saveDiagram(self):
'''!
@if English
@endif
@if Slovak
Uloženie diagramu.
V prípade nezadaného mena vyvolá štandardný dialóg pre zadanie mena a cesty
a uloženie diagramu do súboru.
@endif
'''
self.diagram.mode = MODE.MOVE
# Reset vsetkych komponentov, zmazanie poli v hodnotach parametrov (ukladali by sa do suboru)
for comp in self.diagram.componentList:
comp.sim(SIM_RESET, 0, 0, 0)
if self.fileName == '':
data = QFileDialog.getSaveFileName(self,
'Save',
'..',
filter='*.pse')
self.fileName = data[0]
# kontrola na nezadane meno suboru
if self.fileName != '':
if self.fileName.endswith('.pse') is False:
self.fileName = self.fileName + '.pse'
self.diagram.diagramSave(self.fileName)
self.setWindowTitle(self.fileName)
def saveAsDiagram(self):
'''!
@if English
@endif
@if Slovak
@endif
'''
self.diagram.mode = MODE.MOVE
# Reset vsetkych komponentov, zmazanie poli v hodnotach parametrov (ukladali by sa do suboru)
for comp in self.diagram.componentList:
comp.sim(SIM_RESET, 0, 0, 0)
data = QFileDialog.getSaveFileName(self,
'Save As',
'..',
filter='*.pse')
self.fileName = data[0]
if self.fileName != '':
self.fileName = self.fileName.replace('.txt', '.pse')
if self.fileName.endswith('.pse') is False:
self.fileName = self.fileName + '.pse'
self.diagram.diagramSave(self.fileName)
self.setWindowTitle(self.fileName)
def openDiagramDialog(self):
self.diagram.mode = MODE.MOVE
filename = QFileDialog.getOpenFileName(self,
'Open',
'..',
filter='*.txt *.pse')
if isinstance(filename, tuple):
filename = filename[0] # cut the filter
if filename:
self.loadDiagram(filename)
def loadDiagram(self, filename):
if self.fileName != '':
self.diagram.deleteAll()
self.fileName = filename
self.diagram.diagramLoad(filename)
self.setWindowTitle(filename)
self.add_to_recent(filename)
def exportImage(self):
'''!
@if English
@endif
@if Slovak
@endif
'''
self.diagram.mode = MODE.MOVE
fileName = QFileDialog.getSaveFileName(self,
'Save image',
'..',
filter='*.png')
fn = fileName[0]
if fn is not None:
if not fn.endswith('.png'):
fn = fn + '.png'
if six.PY2:
geometry = self.view.viewport().geometry()
rect = self.view.mapToScene(geometry).boundingRect()
pixMap = QPixmap.grabWidget(self.view,
x=0,
y=0,
width=rect.width(),
height=rect.height())
else:
pixMap = self.view.grab()
pixMap.save(fn)
def simStart(self):
'''!
@if English
@endif
@if Slovak
Spustenie simulacie.
Funkcia vytvori objekt simulatora a spusti simulaciu. Na zaciatku simulacie
su reinicializovane zoznamy prepojeni a komponentov. V pripade prebiehajucej
simulacie sa simulacia restartuje.
@todo simulacia viacerych diagramov spojenie zoznamov komponentov a prepojeni
@endif
'''
self.diagram.mode = MODE.SIMULATION
if self.simEngine:
self.simEngine.stopSimulation()
self.simEngine = SimulatorEngine(self.diagram)
self.simEngine.startSimulation()
return self.simEngine
def simStop(self):
'''!
@if English
@endif
@if Slovak
@endif
'''
if self.simEngine is not None:
self.simEngine.stopSimulation()
time.sleep(0.3) # cakanie na bezpecne ukoncenie threadu
self.simEngine = None
self.diagram.mode = MODE.MOVE
def simReset(self):
"""!
@if English
@endif
@if Slovak
Zastavenie prebiehajucej simulacie a reset vsetkych komponentov.
@endif
"""
self.diagram.mode = MODE.MOVE
# 1. zastavenie simulacie
if self.simEngine is not None:
self.simEngine.stopSimulation()
time.sleep(0.3) # cakanie na bezpecne ukoncenie threadu
self.simEngine = None
# 2. reset vsetkych komponentov, prip. re-inicializacia terminalov
for comp in self.diagram.componentList:
comp.sim(SIM_RESET, 0, 0, 0)
def newDiagramWindow(self):
'''!
@if English
@endif
@if Slovak
Funkcia otvorí nové okno pre diagram.
@endif
'''
self.diagram.mode = MODE.MOVE
self.newWindow = MainPseWindow('')
self.newWindow.setGeometry(120, 120, 800, 500)
self.newWindow.show()
def newDiagram(self):
'''!
@if English
@endif
@if Slovak
@endif
'''
self.diagram.mode = MODE.MOVE
# @todo - v pripade existujuceho diagramu dialog o ulozeni diagramu ...
# ukoncenie simulacie
self.simReset()
# zmazanie vsetkych komponentov
self.diagram.deleteAll()
self.fileName = ''
self.setWindowTitle('Untitled.pse')
def rotateLeft(self):
'''!
@if English
@endif
@if Slovak
@endif
'''
self.diagram.rotateComponentLeft()
self.diagram.mode = MODE.MOVE
def rotateRight(self):
'''!
@if English
@endif
@if Slovak
@endif
'''
self.diagram.rotateComponentRight()
self.diagram.mode = MODE.MOVE
def flipHorizontal(self):
'''!
@if English
@endif
@if Slovak
@endif
'''
self.diagram.mode = MODE.MOVE
self.diagram.flipComponentHorizontal()
def flipVertical(self):
'''!
@if English
@endif
@if Slovak
@endif
'''
self.diagram.mode = MODE.MOVE
self.diagram.flipComponentVertical()
def delComponent(self):
'''!
@if English
@endif
@if Slovak
@endif
'''
self.diagram.mode = MODE.MOVE
for item in self.diagram.selectedItems():
self.diagram.deleteComponent(item)
self.diagram.update()
def move(self):
'''!
@if English
@endif
@if Slovak
@endif
'''
self.diagram.mode = MODE.MOVE
print('mode move')
def frontComponent(self):
'''!
@if English
@endif
@if Slovak
@endif
'''
pass
def backComponent(self):
'''!
@if English
@endif
@if Slovak
@endif
'''
pass
def addNet(self):
'''!
@if English
@endif
@if Slovak
@endif
'''
self.diagram.mode = MODE.ADD_NEW_NET
def delNet(self):
'''!
@if English
@endif
@if Slovak
@endif
'''
for net in self.diagram.netList:
if net.isActive is True:
self.diagram.deleteNet(net)
def selNet(self):
'''!
@if English
@endif
@if Slovak
@endif
'''
self.diagram.mode = MODE.SELECT_NET
def addVertex(self):
'''!
@if English
@endif
@if Slovak
@endif
'''
self.diagram.mode = MODE.INSERT_VERTEX
def delVertex(self):
'''!
@if English
@endif
@if Slovak
@endif
'''
self.diagram.mode = MODE.DELETE_VERTEX
def moveVertex(self):
'''!
@if English
@endif
@if Slovak
@endif
'''
self.diagram.mode = MODE.MOVE
def addConnection(self):
'''!
@if English
@endif
@if Slovak
@endif
'''
self.diagram.mode = MODE.ADD_JUNCTION
def about(self):
'''show about dialog'''
s = "The <b>pse</b> is simple python simulator and block editor<br>" \
"<br>Project of Research Centre University of Zilina<br>" \
"Zilina, Slovak Republic<br>" \
"<b>E-mail</b> [email protected]<br>" \
"<b>Version</b> 151214_0.11<br>"
QMessageBox.about(self, "About pse", s)
def editComponentProperties(self):
'''Open Component Properties dialog on active component'''
comp = self.diagram.activeComponent
if not isinstance(comp, Component):
LOG.debug('Cannot edit: %s' % comp)
return
if comp:
# vypocet polohy okna pre editovanie vlastnosti komponentu
# okno sa nachadza v blizkosti polohy komponentu
winPos = self.view.mapFromScene(
QPoint(comp.position.x(), comp.position.y())) + self.pos()
w = CompProperties(comp, winPos, self)
w.show()
self.diagram.mode = MODE.MOVE
def closeEvent(self, event):
'''!
@if English
@endif
@if Slovak
Ukoncenie aplikacie.
Pri ukonceni aplikacie sa zastavi prebiehajuca simulacia.
@todo - kontrola na neulozeny subor
@endif
'''
reply = QMessageBox.question(self, 'Message', "Are you sure to quit?",
QMessageBox.Yes, QMessageBox.No)
if reply == QMessageBox.Yes:
# ukoncenie simulacie
self.simReset()
# zmazanie vsetkych komponentov a ukoncenie refresovacieho threadu
self.diagram.deleteAll()
self.diagram.stopRefresh()
if self.lib_win:
self.lib_win.close() # close liblary
event.accept()
else:
event.ignore()
def keyPressEvent(self, event):
key = event.key()
if key == Qt.Key_Escape:
print('>>> Key event - ESC - Cancel action')
self.diagram.cancelAction()
elif key == Qt.Key_C:
print('>>> Key event - C - Copy action')
self.diagram.copyComponent()
elif key == Qt.Key_M:
print('>>> Key event - M - Move ')
self.move()
elif key == Qt.Key_N:
print('>>> Key event - N - Add net ')
self.addNet()
elif key == Qt.Key_R:
print('>>> Key event - R - Rotate right')
self.diagram.rotateComponentRight()
elif key == Qt.Key_L:
print('>>> Key event - L - Rotate left')
self.diagram.rotateComponentLeft()
elif key == Qt.Key_Q:
print('>>> Key event - Q - Component list dump')
for comp in self.diagram.componentList:
print(comp)
elif key == Qt.Key_W:
print('>>> Key event - W - Net list dump')
for net in self.diagram.netList:
print(net)
elif key == Qt.Key_Delete:
print('>>> Key event - DEL - Delete')
for item in self.diagram.selectedItems():
if isinstance(item, Component):
self.diagram.deleteComponent(item)
elif isinstance(item, Net):
self.diagram.deleteNet(item)
self.diagram.update()
def init_recent_files(self):
'''inicialization of File->Recent'''
for _ in range(MAX_RECENT):
act = QAction(self, visible=False, triggered=self.__openRecentFile)
self.ui.recent.addAction(act)
self.recentFileActs.append(act)
self._updateRecentFileActions()
def _updateRecentFileActions(self):
''' '''
settings = QSettings("PSE", 'data')
recent = settings.value("recent", defaultValue=[])
numRecentFiles = min(len(recent), MAX_RECENT)
for i in range(numRecentFiles):
path = recent[i]
filename = os.path.basename(path)
text = "&%d %s" % (i + 1, filename)
act = self.recentFileActs[i]
act.setText(text)
act.setData(path)
act.setVisible(True)
act.setStatusTip('%s' % path)
icon = QIcon('./icons/ikona_pse_128x128.png')
act.setIcon(icon)
def add_to_recent(self, filename):
'''remember current file to the recent files '''
settings = QSettings("PSE", 'data')
recent = settings.value("recent", defaultValue=[])
try:
recent.remove(filename)
except ValueError:
pass
recent.insert(0, filename)
settings.setValue('recent', recent)
settings.sync()
self._updateRecentFileActions()
def __openRecentFile(self):
'''open choosed diagram from recent files'''
action = self.sender()
filename = str(action.data())
self.loadDiagram(filename)
def show_libwindow(self):
'''Show liblary window'''
if not self.lib_win:
self.lib_win = Library()
self.lib_win.setGeometry(20, 20, 400, 500)
self.lib_win.show()
class AlphaShape(Shape):
'''
This class represents a description of the Alpha Shape of a given Diagram
:param diagram_or_container: Diagram or Container class to use for computations
**NOTE** if Container class is used to instantiate then the class will create Diagram for internal use
'''
def __init__(self, diagram_or_container):
'''
diagram_or_container is either Diagram or Container, if container, then Diagram is internally created
'''
# make sure we have diagram
if isinstance(diagram_or_container, Diagram):
# print "AlphaShape::__init__(): we have Diagram"
self.diagram = diagram_or_container
elif isinstance(diagram_or_container, Container):
# make new diagram
# print "AlphaShape::__init__(): we have Container"
self.diagram = Diagram(diagram_or_container)
else:
raise TypeError(
"AlphaShape.__init__(): Diagram or Container required but something else given"
)
# do rest of the initialization
self._diagram_handle = self.diagram._diagram_handle
# print "Diagram handle =", self.diagram._diagram_handle
# create item on the C++ side
self._shape_handle = dmga2py.new_alpha_shape(self._diagram_handle)
def size(self):
'''
:return: number of cells in this shape, the same as size in diagram
'''
return self.diagram.size()
def get_cell(self, number):
'''
:return: one cell of this shape
The class of shape depends on the type of the shape
in Alpha Shape it is Alpha Complex (subset of...) for this cell
'''
(shape_cell_handle, cell_handle,
complex_handle) = dmga2py.alpha_shape_get_shape_cell(
self._shape_handle, number)
# complex_handle = dmga2py.alpha_shape_get_complex(self._shape_handle, number)
return AlphaShapeCell(shape_cell_handle, cell_handle, complex_handle)
def __del__(self):
'''
free all C++ objects if necessary
'''
dmga2py.free_object(self._shape_handle)
def __iter__(self):
'''
:return: iterator over all shape cells in this shape
'''
return ShapeIterator(self)
def max_alpha_threshold(self):
'''
:return: max alpha_threshold - value of alpha at which all elements from diagram belongs to the alpha-complex for all cells
**NOTE** max_threshold is computed only for those cells that were actually created by for
example get_cell() or get_cells() or if diagram has cache_on property set to ON (True).
'''
return dmga2py.alpha_shape_get_max_alpha_threshold(self._shape_handle)
import sky_area
from input_file import InputFile
from diagram import Diagram
from coord_calc import CoordCalc
f = InputFile('stardata.csv')
area = sky_area.SKY_AREA_ORION
star_data_list = f.get_stars(area)
cc = CoordCalc(star_data_list, area, 500)
cc.process()
d = Diagram('My Star Map', area, star_data_list)
list(map(d.add_curve, cc.calc_curves()))
d.render_svg('star-chart.svg')
class SASAShape(Shape):
'''
This is a Solvent Accessible Surface Shape (SAS) for a given Diagram. It is
used mainly to compute Solvent Accessible Surface Area (SASA)
SAS is a shape of the union of balls and thus is strongly connected with Alpha SHape.
Alpha SHape is more like a topological description of the Shape (what is connected with what), while
SAS is the description of the actual union of balls. If you are interested only in topological aspect
we suggest Alpha Shapes as those are a bit faster to compute.
:param diagram_or_container: Diagram or Container class to use for computations
**NOTE** if Container class is used to instantiate then the class will create Diagram for internal use
'''
def __init__(self, diagram_or_container):
'''
diagram_or_container is either Diagram or Container, if container, then Diagram is internally created
'''
# make sure we have diagram
if isinstance(diagram_or_container, Diagram):
self.diagram = diagram_or_container
elif isinstance(diagram_or_container, Container):
# make new diagram
self.diagram = Diagram(diagram_or_container)
else:
raise TypeError(
"AlphaShape.__init__(): Diagram or Container required but something else given"
)
# do rest of the initialization
self._diagram_handle = self.diagram._diagram_handle
# create item on the C++ side
self._shape_handle = dmga2py.new_sasa_shape(self._diagram_handle)
def size(self):
'''
:return: number of cells in this shape, the same as size in diagram
'''
return self.diagram.size()
def get_cell(self, number):
'''
:return: one cell of this shape
the class of shape depends on the type of the shape
in SASA Shape it is SASACell for this cell that holds the COntour information (SASArcs)
'''
(shape_cell_handle, cell_handle,
contour_handle) = dmga2py.sasa_shape_get_shape_cell(
self._shape_handle, number)
return SASACell(shape_cell_handle, cell_handle, contour_handle, number)
def __del__(self):
'''
free all C++ objects if necessary
'''
# TODO: why it is caousing core dump???????
dmga2py.free_object(self._shape_handle)
pass
def __iter__(self):
'''
:return: iterator over all shape cells in this shape
'''
return ShapeIterator(self)
def sas_area(self):
'''
:return: area of all computed cells in this SASA Shape that is area of the intersection of sphere with its voronoi cell
'''
return dmga2py.sasa_shape_get_area(self._shape_handle)
def sas_volume(self):
'''
:return: volume of all computed cells in this SASA Shape that is volume of the intersection of ball with its voronoi cell
'''
return dmga2py.sasa_shape_get_volume(self._shape_handle)
class BPNN(object):
def __init__(self,
dataset,
learning_rate=0.01,
n_iter=10000,
momentum=0.9,
shutdown_condition=0.01):
self.n_iter = n_iter
self.dataset = dataset
self.learning_rate = learning_rate
self.x = dataset.train_x
self.Y = dataset.train_Y
self.shutdown_condition = shutdown_condition
self.cost = []
self.momentum = momentum
self.setup()
self.diagram = Diagram(self)
def setup(self):
self.set_nn_architecture()
self.set_weight()
# step1
def set_nn_architecture(self):
self.input_node = self.x.shape[1]
self.output_node = self.Y.shape[1]
self.hidden_node = int((self.input_node + self.output_node) / 2)
# bias
self.h_b = np.random.random(self.hidden_node) * 0.3 + 0.1
self.y_b = np.random.random(self.output_node) * 0.3 + 0.1
# step2
def set_weight(self):
self.w1 = np.random.random((self.input_node, self.hidden_node))
self.w2 = np.random.random((self.hidden_node, self.output_node))
# step3
def predict(self, x, Y):
self.h = self.sigmoid((np.dot(x, self.w1) + self.h_b))
self.y = self.sigmoid((np.dot(self.h, self.w2) + self.y_b))
zy = np.where(self.y > 0.5, 1, 0)
p_y = Y - zy
self.acc = 0
for i in p_y:
if (i.sum() == 0):
self.acc += 1
self.acc = self.acc / Y.shape[0] * 100.0
return self
# step4
def backend(self):
E = (self.Y - self.y)
errors = np.sum(np.square(E)) / self.Y.shape[1] / self.Y.shape[0]
#### 輸出層 delta 計算
delta_y = E * self.y * (1 - self.y)
### 隱藏層 delta 計算
delta_h = (1 - self.h) * self.h * np.dot(delta_y, self.w2.T)
# self.w2 += self.learning_rate * self.h.T.dot(delta_y) + self.momentum * self.h.T.dot(delta_y)
# self.w1 += self.learning_rate * self.x.T.dot(delta_h) + self.momentum * self.x.T.dot(delta_h)
self.w2 += self.learning_rate * self.h.T.dot(delta_y)
self.w1 += self.learning_rate * self.x.T.dot(delta_h)
self.y_b = self.learning_rate * delta_y.sum()
self.h_b = self.learning_rate * delta_h.sum()
return errors
def train(self):
self.error = 0
for _iter in range(0, self.n_iter):
self.predict(self.x, self.Y)
self.error = self.backend()
self.cost.append(self.error)
# if (_iter % 1000 == 0):
# print("Accuracy：%.2f" % self.acc)
if (self.acc >= 98):
return self
return self
def test(self):
self.predict(self.dataset.test_x, self.dataset.test_Y)
return self
def sigmoid(self, x):
return 1 / (1 + np.exp(-x))
def draw(self, xlabel='', ylabel='', legend_loc='', title=''):
self.diagram.draw(xlabel, ylabel, legend_loc, title)
def __init__(self, text_file):
self.dg = Diagram(text_file) # Инициализация синаксичского анализатора
self.scaner = Scaner(text_file) #Инициализация сканера
self.__tree = None # дерево идентификаторов
self.interpret = False # флаг интепретации
self.position = 0
class Interpretator():
def __init__(self, text_file):
self.dg = Diagram(text_file) # Инициализация синаксичского анализатора
self.scaner = Scaner(text_file) #Инициализация сканера
self.__tree = None # дерево идентификаторов
self.interpret = False # флаг интепретации
self.position = 0
def run(self):
# Анализируем синтаксис
self.dg.S()
self.__tree = self.dg.getTree()
# Начинаем интепретацию
self.interpret = True
self.globalValue() # глобальные переменные
def globalValue(self):
_type = '' #Тип лексемы
self.position = self.scaner.get_current_position(
) #Запомнить текущую позицию
_type = self.scaner.scan() #Получить текущую лексему
self.scaner.set_current_position(
self.position) #Вернуть старую позицию
while (_type == INT or _type == INT64 or _type == VOID):
if (_type != VOID):
self.W()
self.position = self.scaner.get_current_position()
_type = self.scaner.scan()
self.scaner.set_current_position(self.position)
#Список данных
def W(self):
_type = self.scaner.scan() #Получить текущую лексему
self.Z()
self.position = self.scaner.get_current_position(
) #Запомнить текущую позицию
_type = self.scaner.scan() #Получить текущую лексему
while (_type == COMMA):
self.Z()
self.position = self.scaner.get_current_position(
) #Запомнить текущую позицию
_type = self.scaner.scan() #Получить текущую лексему
self.scaner.set_current_position(
self.position) #Вернуть старую позицию
_type = self.scaner.scan() #Получить текущую лексему
if (_type == SEMICOLON):
return
#Переменная, массив и индекс
def Z(self):
self.position = self.scaner.get_current_position(
) #Запомнить текущую позицию
_type = self.scaner.scan() # Считываем идентификатор
_type = self.scaner.scan() # Квадратные скобки, запятая или сохранить
self.scaner.set_current_position(
self.position) #Вернуть старую позицию
if (_type == LSBRACKET):
pass
else:
_type = self.scaner.scan() #Получить текущую лексему
currentID = self.__tree.semGetType(''.join(self.scaner.get_lex()))
self.position = self.scaner.get_current_position(
) #Запомнить текущую позицию
_type = self.scaner.scan() # Квадратные скобки, запятая или сохранить
if (_type == SAVE):
value = self.expression()
self.__tree.semSetData(currentID, value)
elif (_type == LSBRACKET):
pass
else:
self.scaner.set_current_position(
self.position) #Вернуть старую позицию
#Выражение
def expression(self):
self.position = self.scaner.get_current_position(
) #Запомнить текущую позицию
_type = self.scaner.scan() #Получить текущую лексему
if (_type != PLUS and _type != MINUS):
self.scaner.set_current_position(
self.position) #Вернуть старую позицию
if (_type == PLUSPLUS or _type == MINUSMINUS):
self.position = self.scaner.get_current_position(
) #Запомнить текущую позицию
_type = self.scaner.scan() #Получить текущую лексему
self.addend()
self.position = self.scaner.get_current_position(
) #Запомнить текущую позицию
_type = self.scaner.scan() #Получить текущую лексему
if (_type == PLUSPLUS or _type == MINUSMINUS):
return
while ((_type >= LT and _type <= NEQ) or _type == RMOVE
or _type == LMOVE):
self.addend()
self.position = self.scaner.get_current_position(
) #Запомнить текущую позицию
_type = self.scaner.scan() #Получить текущую лексему
self.scaner.set_current_position(
self.position) #Вернуть старую позицию
#Слагаемое
def addend(self):
self.multiplier()
c_p = self.scaner.get_current_position() #Запомнить текущую позицию
_type = self.scaner.scan() #Получить текущую лексему
while (_type == PLUS or _type == MINUS):
self.multiplier()
c_p = self.scaner.get_current_position(
) #Запомнить текущую позицию
_type = self.scaner.scan() #Получить текущую лексему
self.scaner.set_current_position(c_p) #Вернуть старую позицию
#Множитель
def multiplier(self):
value, typeValue = self.elementaryExpression()
c_p = self.scaner.get_current_position() #Запомнить текущую позицию
_type = self.scaner.scan() #Получить текущую лексему
while (_type == DIV or _type == MOD or _type == MULT):
value = self.elementaryExpression()
c_p = self.scaner.get_current_position(
) #Запомнить текущую позицию
_type = self.scaner.scan() #Получить текущую лексему
self.scaner.set_current_position(c_p) #Вернуть старую позицию
#Элементарное выражение
def elementaryExpression(self):
_type = self.scaner.scan() #Получить текущую лексему
if (_type == ID):
# Поиск имени идентификатора в таблице
v = self.__tree.semGetType(''.join(self.scaner.get_lex()))
value = self.__tree.getData(v)
typeValue = self.__tree.getType(v)
c_p = self.scaner.get_current_position(
) #Запомнить текущую позицию
_type = self.scaner.scan() #Проверить: не массив ли?
if (_type != LSBRACKET):
self.scaner.set_current_position(c_p) #Вернуть старую позицию
return value, typeValue
else:
pass
elif (_type == LBRACKET):
self.expression()
_type = self.scaner.scan() #Получить закрывающуюся скобку
elif (_type == CONSTINT or _type == CONSTINT16):
v = ''.join(self.scaner.get_lex())
if (len(v) > 11):
self.scaner.printError(
"int is greater than the range of values")
value = int(v)
if (value > 2147483647 or value < -2147483648):
self.scaner.printError(
"int is greater than the range of values")
return value, INT
import logging
logging.basicConfig(level=logging.INFO)
from diagram import Diagram
from metrics import Metrics
from results_file import *
logging.info('INICIANDO: CÁLCULO DAS MÉTRICAS E CONSTRUÇÃO DOS DIAGRAMAS E RELATÓRIO')
metrics = Metrics("result/resultados_stemmer.csv")
eleven_points, f1, prec5, prec10, r_prec, mean_ap, mrr, dcg, avg_dcg, ndcg = metrics.all_metrics()
metrics = Metrics("result/resultados_nostemmer.csv")
eleven_points_no, f1_no, prec5_no, prec10_no, r_prec_no, mean_ap_no, mrr_no, dcg_no, avg_dcg_no, ndcg_no = metrics.all_metrics()
diff_precision = metrics.r_precision_comparison("result/resultados_stemmer.csv", "result/resultados_nostemmer.csv")
diag = Diagram()
#11 points stemmer
diag.diagram_eleven_points(eleven_points, "11pontos-stemmer-1.png")
result_file(eleven_points, ['Recall', 'Precision'], "11pontos-stemmer-1.csv")
#11 points without stemmer
diag.diagram_eleven_points(eleven_points_no, "11pontos-nostemmer-2.png")
result_file(eleven_points_no, ['Recall', 'Precision'], "11pontos-nostemmer-2.csv")
#f1 stemmer
diag.diagram_f1(f1, "f1-stemmer-3.png")
result_file(f1, ['QueryNumber', 'F1'], "f1-stemmer-3.csv")
#f1 nostemmer
diag.diagram_f1(f1_no, "f1-nostemmer-4.png")
result_file(f1_no, ['QueryNumber', 'F1'], "f1-nostemmer-4.csv")
#precision5 stemmer
#!/usr/bin/python2
import argparse, os.path
from diagram import Diagram
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Process UMLDown files.')
parser.add_argument('file', metavar='FILE', type=str, nargs=1,
help='the file to process')
args = parser.parse_args()
fn = args.file[0]
dia = Diagram()
dia.parse(fn)
dia.render(os.path.splitext(fn)[0] + '.png')
def main(argv):
np.set_printoptions(linewidth=300)
# defaults
verbose = False
noplot = False
Nmin = 3
Nmax = 3
plotorb = -1
plotopt = {
'diagram': True,
'wavef': False,
'decoup': False,
'gfact': False,
'sfact': False
}
ranged = 0.4
Nd = 40
kappa = 0.05
mu = -1
quench = 0.9
gR = 0.35
savefilepath = None
DeltaN2 = True
argparser = argparse.ArgumentParser(
description='Calculation of Nilsson diagrams and wave functions.',
add_help=False)
requiredargs = argparser.add_argument_group('required arguments')
requiredargs.add_argument(
"-N",
"-n",
"--nosc",
required=True,
nargs="+",
dest="Nosc",
type=int,
help=
"oscillator shell N, or a range of oscillator shells Nmin Mmax, e.g. -N 3 or -N 1 3"
)
argparser.add_argument("-o",
"--orbital",
dest="orb",
type=int,
help="number of orbital to be plotted")
argparser.add_argument(
"-p",
"--property",
dest="prop",
choices=[
'wavef', 'wf', 'decoup', 'a', 'gfactor', 'gfact', 'g', 'sfactor',
'sfact', 's'
],
help=
"which property should be plotted. The options are wave function: \"wavef\" or \"wf\", decoupling parameter: \"decoup\" or \"a\", g-factor: \"gfactor\", \"gfact\", or \"g\", spectroscopic factors: \"sfactor\", \"sfact\", or \"s\""
)
argparser.add_argument(
"-k",
"--kappa",
dest="kappa",
type=float,
help="kappa value for the energy calculations, default value is 0.05")
argparser.add_argument(
"-m",
"--mu",
dest="mu",
type=float,
help=
"mu value for the energy calculations, default value depend on the value of N"
)
argparser.add_argument(
"-Nd",
"--ndelta",
dest="Nd",
type=int,
help="number of steps in delta, typical value is 40")
argparser.add_argument(
"-r",
"--ranged",
dest="ranged",
type=float,
help="range of delta values [-ranged,ranged], typical value is 0.4")
argparser.add_argument(
"-gR",
"--gfactR",
dest="gfactR",
type=float,
help="g factor options, parameter g_R, typically Z/A")
argparser.add_argument(
"-q",
"--gquench",
dest="gquench",
type=float,
help="g factor options, quenching of spin g-factor, default 0.7")
argparser.add_argument("-w",
"--write",
dest="write",
type=str,
help="write the calculation to output file")
argparser.add_argument("-noplot",
"--noplot",
help="do not plot",
action="store_true")
argparser.add_argument("-ndN2",
"--no-deltaN2",
dest="nodeltaN2",
help="disable deltaN=2 coupling",
action="store_true")
argparser.add_argument("-h",
"--help",
action="help",
help="show this help message and exit")
argparser.add_argument("-t",
"--test",
help="excute testing functions",
action="store_true")
argparser.add_argument("-v",
"--verbose",
help="verbose output",
action="store_true")
argparser.add_argument('--version', action='version', version=version)
argparser._action_groups.reverse()
args = argparser.parse_args()
if args.test:
print("test calculation")
test()
sys.exit()
if not (1 <= len(args.Nosc) <= 2):
raise argparser.error(
"-N expects one or two values, oscillator shell N, or range of oscillator shells -N 3 or -N 1 3"
)
if args.verbose:
verbose = True
if args.noplot:
noplot = True
if args.nodeltaN2:
DeltaN2 = False
if len(args.Nosc) == 1:
Nmin = args.Nosc[0]
Nmax = args.Nosc[0]
print("calculation for N = %d" % Nmax)
if len(args.Nosc) == 2:
Nmin = min(args.Nosc)
Nmax = max(args.Nosc)
print("calculation for N = [%d,%d]" % (Nmin, Nmax))
if args.orb is not None and args.orb > -1:
plotopt['diagram'] = False
plotorb = args.orb
if args.prop:
if args.prop in ("wf", "wf"):
plotopt['wavef'] = True
if args.prop in ("decoup", "a"):
plotopt['decoup'] = True
if args.prop in ("gfactor", "gfact", "g"):
plotopt['gfact'] = True
if args.prop in ("sfactor", "sfact", "s"):
plotopt['sfact'] = True
else:
plotopt['wavef'] = True
elif args.prop is not None:
raise argparser.error(
"-p/--property needs to specify which orbit, e.g. \" -o 3 \"")
if args.Nd is not None:
if args.Nd < 1:
raise argparser.error(
"-Nd/--ndelta must be 1 or larger, typically around 40")
else:
Nd = args.Nd
if args.ranged is not None:
if args.ranged < 0:
raise argparser.error(
"-r/--ranged must be positive, typically around 0.4")
else:
ranged = args.ranged
if args.kappa is not None:
if args.kappa < 0:
raise argparser.error(
"-k/--kappa must be positive, default value is 0.05")
else:
kappa = args.kappa
if args.mu is not None:
if args.mu < 0:
raise argparser.error(
"-m/--mu must be 0 or positive, default value is between 0 and 0.45 depending on the shell"
)
else:
mu = args.mu
if args.gfactR is not None:
if args.gfactR < 0:
raise argparser.error(
"-g/--gfact must be positive, typical value gR = Z/A, default is 0.35"
)
else:
gR = args.gfactR
if args.gquench is not None:
if args.gquench < 0:
raise argparser.error(
"-g/--gquench must be positive, default is 0.70")
else:
quench = args.gquench
if args.write is not None:
savefilepath = args.write
print("%d steps in delta in [%.2f,%.2f]" % (Nd, ranged, ranged))
## basic model space and parameters
Nnuc = (Nmax + 1) * (Nmax + 2) * (Nmax + 3) / 3 - (Nmin - 1 + 1) * (
Nmin - 1 + 2) * (Nmin - 1 + 3) / 3
Nlev = int(Nnuc / 2)
print("number of Nilsson levels:", Nlev)
if plotorb >= Nlev:
raise argparser.error(
"invalid orbit selected, number of Nilsson levels = %d, cannot plot orbit orb = %d (0<=orb<N)"
% (Nlev, plotorb))
muN = [0, 0, 0, 0.35, 0.45, 0.45, 0.45, 0.40]
par = {'kappa': kappa, 'mu': muN[Nmax], 'delta': 0.0}
if mu != -1:
par['mu'] = mu
print("kappa = %.3f, mu = %.3f" % (par['kappa'], par['mu']))
#options for the nillson diagram
diaopt = {'mind': -ranged, 'maxd': ranged, 'Nd': Nd}
print(DeltaN2)
diag = Diagram(kappa=par['kappa'],
mu=par['mu'],
Nd=diaopt['Nd'],
ranged=diaopt['maxd'],
Nmin=Nmin,
Nmax=Nmax,
DeltaN2=DeltaN2,
verbose=verbose)
diag.rundiagram()
## plotting
ax = []
if plotopt['diagram']:
fig = plt.figure(figsize=[6, 9])
ax.append(plt.subplot(1, 1, 1))
if Nmin == Nmax:
plt.title(
"Nilsson Diagram for $N = %d$, $\kappa$ = %.2f, $\mu$ = %.2f" %
(Nmax, par['kappa'], par['mu']))
else:
plt.title(
"Nilsson Diagram $N = [%d,%d]$, $\kappa$ = %.2f, $\mu$ = %.2f"
% (Nmin, Nmax, par['kappa'], par['mu']))
plt.plot([0, 0], [np.min(diag.el), np.max(diag.el)],
ls="--",
linewidth=1,
color='k')
for l in range(diag.Nlev):
plt.plot(diag.deltas,
diag.el[l],
ls="--" if diag.nQN[l][1] == 1 else "-")
plt.text(diag.deltas[-1] + textshift,
diag.el[l][-1],
"$%s$, %d" % (diag.Nlabel(diag.nQN[l]), l),
ha='left')
plt.text(diag.deltas[0] - textshift,
diag.el[l][0],
"$%s$, %d" % (diag.Nlabel(diag.nQN[l]), l),
ha='right')
plt.ylabel('$E/\hbar\omega$')
## write out to file
if savefilepath is not None:
with open(savefilepath, "w") as output:
if Nmin == Nmax:
ntext = "N = %d" % Nmax
else:
ntext = "N = [%d,%d]" % (Nmin, Nmax)
output.write(
"#Nilsson Diagram for %s, with kappa = %.2f, mu = %.3f\n" %
(ntext, par['kappa'], par['mu']))
output.write("#delta\t\t")
for l in range(diag.Nlev):
output.write("%s\t" % diag.Nlabel(diag.nQN[l]))
output.write("\n")
np.savetxt(output,
np.column_stack(
(diag.deltas, np.transpose(diag.el))),
fmt='%.6f',
delimiter='\t')
else:
print("delta ")
for d in np.linspace(-0.4, 0.4, num=9, endpoint=True):
print("%.3f\t" % d, end="")
if plotopt['wavef']:
fig = plt.figure(figsize=[6, 6])
ax.append(plt.subplot(1, 1, 1))
rwf, rqn = diag.wavefunction(plotorb)
plt.title("wave function composition for $%s$ level" %
diag.Nlabel(diag.nQN[plotorb]))
if Nd == 40 and ranged == 0.4:
print('\nwave funtion composition')
plt.plot([0, 0], [np.min(rwf), np.max(rwf)],
ls="--",
linewidth=1,
color='k')
plt.plot([diag.deltas[0] - 0.1, diag.deltas[-1] + 0.1], [0, 0],
ls="--",
linewidth=1,
color='k')
for l in range(len(rqn)):
plt.plot(diag.deltas, rwf[l])
plt.text(diag.deltas[-1] + textshift,
rwf[l][-1],
"$%s$" % (diag.Slabel(rqn[l])),
ha='left')
plt.text(diag.deltas[0] - textshift,
rwf[l][0],
"$%s$" % (diag.Slabel(rqn[l])),
ha='right')
if Nd == 40 and ranged == 0.4:
for d in np.linspace(-0.4, 0.4, num=9, endpoint=True):
i = np.where(abs(diag.deltas - d) < eps)[0]
print("%.4f\t" % rwf[l][i], end="")
print(diag.Slabel(rqn[l]))
plt.ylabel('$c_{\Omega j}$')
if savefilepath is not None:
with open(savefilepath, "w") as output:
if Nmin == Nmax:
ntext = "N = %d" % Nmax
else:
ntext = "N = [%d,%d]" % (Nmin, Nmax)
output.write(
"#wave function composition for %s level, calculated for %s, with kappa = %.2f, mu = %.3f\n"
% (diag.plainNlabel(
diag.nQN[plotorb]), ntext, par['kappa'], par['mu']))
output.write("#delta\t\t")
for l in range(len(rqn)):
output.write("%s\t\t" % diag.plainSlabel(rqn[l]))
output.write("\n")
np.savetxt(output,
np.column_stack((diag.deltas, np.transpose(rwf))),
fmt='%.6f',
delimiter='\t')
# check if this is K = 1/2
if plotopt['decoup'] and diag.nQN[plotorb][0] == 1. / 2:
a = diag.decoupling(plotorb)
sz, gKN, gKP, gN, gP, bN, bP = diag.gfactors(plotorb, quench, gR)
fig = plt.figure(figsize=[6, 6])
ax.append(plt.subplot(2, 1, 1))
if type(a) is not np.ndarray:
return
plt.title("decoupling parameters for $%s$ level" %
diag.Nlabel(diag.nQN[plotorb]))
plt.plot([0, 0], [np.min(a), np.max(a)],
ls="--",
linewidth=1,
color='k')
plt.plot(diag.deltas, a)
plt.ylabel('$a$')
plt.setp(ax[-1].get_xticklabels(), visible=False)
ax[-1].tick_params(axis='y', which='major')
ax[-1].tick_params(axis='y', which='minor')
ax.append(plt.subplot(2, 1, 2, sharex=ax[0]))
mi = np.min([np.min(bN), np.min(bP)])
ma = np.max([np.max(bN), np.max(bP)])
ax[-1].plot([0, 0], [mi, ma], ls="--", linewidth=1, color='k')
ax[-1].plot(diag.deltas, bN, label="neutron")
ax[-1].plot(diag.deltas, bP, label="proton")
ax[-1].tick_params(axis='both', which='major')
ax[-1].tick_params(axis='both', which='minor')
ax[-1].set_ylabel('$b_{0}$', fontsize=12)
plt.legend(loc="best", fancybox=False, fontsize=12)
if Nd == 40 and ranged == 0.4:
print("\ndecouling parameter")
for d in np.linspace(-0.4, 0.4, num=9, endpoint=True):
i = np.where(abs(diag.deltas - d) < eps)[0]
print("%.4f\t" % a[i], end="")
print()
if savefilepath is not None:
with open(savefilepath, "w") as output:
if Nmin == Nmax:
ntext = "N = %d" % Nmax
else:
ntext = "N = [%d,%d]" % (Nmin, Nmax)
output.write(
"#decoupling parameters for %s level, calculated for %s, with kappa = %.2f, mu = %.3f\n"
% (diag.Nlabel(
diag.nQN[plotorb]), ntext, par['kappa'], par['mu']))
output.write("#delta\t\ta\t\tbN\t\tbP\n")
np.savetxt(output,
np.column_stack(
(diag.deltas, np.transpose(a), np.transpose(bN),
np.transpose(bP))),
fmt='%.6f',
delimiter='\t')
if plotopt['gfact']:
fig = plt.figure(figsize=[8, 9])
if diag.nQN[plotorb][0] == 1. / 2:
ax.append(plt.subplot2grid((4, 1), (0, 0)))
ax.append(plt.subplot2grid((4, 1), (1, 0), sharex=ax[0]))
ax.append(plt.subplot2grid((4, 1), (2, 0), sharex=ax[0]))
ax.append(plt.subplot2grid((4, 1), (3, 0), sharex=ax[0]))
else:
ax.append(plt.subplot2grid((3, 1), (0, 0)))
ax.append(plt.subplot2grid((3, 1), (1, 0), sharex=ax[0]))
ax.append(plt.subplot2grid((3, 1), (2, 0), sharex=ax[0]))
sz, gKN, gKP, gN, gP, bN, bP = diag.gfactors(plotorb, quench, gR)
#fN = b0N*(gKN-gR)
#fP = b0P*(gKP-gR)
fN = bN * (gKN - gR)
fP = bP * (gKP - gR)
if type(sz) is not np.ndarray:
return
ax[0].set_title("$g$-factor for $%s$ level" %
diag.Nlabel(diag.nQN[plotorb]))
ax[0].plot([0, 0], [np.min(sz), np.max(sz)],
ls="--",
linewidth=1,
color='k')
ax[0].plot([diag.deltas[0] - 0.1, diag.deltas[-1] + 0.1], [0, 0],
ls="--",
linewidth=1,
color='k')
plt.setp(ax[0].get_xticklabels(), visible=False)
ax[0].plot(diag.deltas, sz)
ax[0].set_ylabel('$<s_z>$')
mi = np.min([np.min(gKN), np.min(gKP)])
ma = np.max([np.max(gKN), np.max(gKP)])
ax[1].plot([0, 0], [mi, ma], ls="--", linewidth=1, color='k')
ax[1].plot([diag.deltas[0] - 0.1, diag.deltas[-1] + 0.1], [0, 0],
ls="--",
linewidth=1,
color='k')
ax[1].plot(diag.deltas, gKN, label="neutron")
ax[1].plot(diag.deltas, gKP, label="proton")
plt.setp(ax[1].get_xticklabels(), visible=False)
ax[1].tick_params(axis='y', which='major')
ax[1].tick_params(axis='y', which='minor')
ax[1].set_ylabel('$g_K$', fontsize=12)
mi = np.min([np.min(gN), np.min(gP)])
ma = np.max([np.max(gN), np.max(gP)])
ax[2].plot([0, 0], [mi, ma], ls="--", linewidth=1, color='k')
ax[2].plot([diag.deltas[0] - 0.1, diag.deltas[-1] + 0.1], [0, 0],
ls="--",
linewidth=1,
color='k')
ax[2].plot(diag.deltas, gN, label="neutron")
ax[2].plot(diag.deltas, gP, label="proton")
ax[2].set_xlim(diag.deltas[0] - 0.1, diag.deltas[-1] + 0.1)
plt.setp(ax[2].get_xticklabels(), visible=False)
ax[2].tick_params(axis='y', which='major')
ax[2].tick_params(axis='y', which='minor')
ax[2].set_ylabel('$g$', fontsize=12)
if diag.nQN[plotorb][0] == 1. / 2:
mi = np.min([np.min(fN), np.min(fP)])
ma = np.max([np.max(fN), np.max(fP)])
ax[3].plot([0, 0], [mi, ma], ls="--", linewidth=1, color='k')
ax[3].plot([diag.deltas[0] - 0.1, diag.deltas[-1] + 0.1], [0, 0],
ls="--",
linewidth=1,
color='k')
ax[3].plot(diag.deltas, fN, label="neutron")
ax[3].plot(diag.deltas, fP, label="proton")
ax[3].set_ylabel('$b_0(g_K-g_R)$', fontsize=12)
if Nd == 40 and ranged == 0.4:
print("\ng-factors")
for d in np.linspace(-0.4, 0.4, num=9, endpoint=True):
i = np.where(abs(diag.deltas - d) < eps)[0]
print("%.4f\t" % gN[i], end="")
print("neutron")
for d in np.linspace(-0.4, 0.4, num=9, endpoint=True):
i = np.where(abs(diag.deltas - d) < eps)[0]
print("%.4f\t" % gP[i], end="")
print("proton")
if savefilepath is not None:
with open(savefilepath, "w") as output:
if Nmin == Nmax:
ntext = "N = %d" % Nmax
else:
ntext = "N = [%d,%d]" % (Nmin, Nmax)
output.write(
"#g-factor for %s level, calculated for %s, with kappa = %.2f, mu = %.3f\n"
% (diag.plainNlabel(
diag.nQN[plotorb]), ntext, par['kappa'], par['mu']))
output.write(
"#delta\t\tsz\t\tgKN\t\tgKP\t\tgN\t\tgP\t\tbN\t\tbP\t\tbN(gK-gR)\t\tbP(gK-gR)\n"
)
np.savetxt(output,
np.column_stack(
(diag.deltas, np.transpose(sz),
np.transpose(gKN), np.transpose(gKP),
np.transpose(gN), np.transpose(gP),
np.transpose(bN), np.transpose(bP),
np.transpose(fN), np.transpose(fP))),
fmt='%.6f',
delimiter='\t')
if plotopt['sfact']:
fig = plt.figure(figsize=[6, 6])
ax.append(plt.subplot(2, 1, 1))
rsf, rqn = diag.sfactors(plotorb)
plt.title("spectroscopic factors for $%s$ level" %
diag.Nlabel(diag.nQN[plotorb]))
if Nd == 40 and ranged == 0.4:
print('\nspectroscopic factors')
plt.plot([0, 0], [0.0, np.max(rsf)], ls="--", linewidth=1, color='k')
for l in range(len(rqn)):
plt.plot(diag.deltas, rsf[l])
plt.text(diag.deltas[-1] + textshift,
rsf[l][-1],
"$%s$" % (diag.Slabel(rqn[l])),
ha='left')
plt.text(diag.deltas[0] - textshift,
rsf[l][0],
"$%s$" % (diag.Slabel(rqn[l])),
ha='right')
if Nd == 40 and ranged == 0.4:
for d in np.linspace(-0.4, 0.4, num=9, endpoint=True):
i = np.where(abs(diag.deltas - d) < eps)[0]
print("%.4f\t" % rsf[l][i], end="")
print(diag.Slabel(rqn[l]))
plt.ylabel('$|c_{\Omega j}|^2$')
plt.setp(ax[-1].get_xticklabels(), visible=False)
ax[-1].tick_params(axis='y', which='major')
ax[-1].tick_params(axis='y', which='minor')
ax.append(plt.subplot(2, 1, 2, sharex=ax[0]))
""" from Ii = 0 to any orbital, nucleon adding """
g2 = 2
maxsf = 0
for l in range(len(rqn)):
jfact = 1. / (2 * rqn[l][2] + 1)
dK = diag.nQN[plotorb][0]
j = rqn[l][2]
If = rqn[l][2]
Kf = diag.nQN[plotorb][0]
cg = CG(0, 0, j, dK, If, Kf)
sf = jfact * g2 * cg**2 * rsf[l]
maxsf = max(np.max(sf), maxsf)
ax[1].plot(diag.deltas, sf)
ax[1].text(diag.deltas[-1] + textshift,
sf[-1],
"$%s$" % (diag.Slabel(rqn[l])),
ha='left')
ax[1].text(diag.deltas[0] - textshift,
sf[0],
"$%s$" % (diag.Slabel(rqn[l])),
ha='right')
ax[-1].tick_params(axis='both', which='major')
ax[-1].tick_params(axis='both', which='minor')
ax[-1].set_ylabel(r'$S(0^+\rightarrow j)$', fontsize=12)
if savefilepath is not None:
with open(savefilepath, "w") as output:
if Nmin == Nmax:
ntext = "N = %d" % Nmax
else:
ntext = "N = [%d,%d]" % (Nmin, Nmax)
output.write(
"#spectroscopic factors for %s level, calculated for %s, with kappa = %.2f, mu = %.3f\n"
% (diag.plainNlabel(
diag.nQN[plotorb]), ntext, par['kappa'], par['mu']))
output.write("#delta\t\t")
for l in range(len(rqn)):
output.write("%s\t\t" % diag.plainSlabel(rqn[l]))
output.write("\n")
np.savetxt(output,
np.column_stack((diag.deltas, np.transpose(rsf))),
fmt='%.6f',
delimiter='\t')
plt.xlabel('$\delta$')
plt.tick_params(axis='both', which='major')
plt.tick_params(axis='both', which='minor')
plt.xlim(diag.deltas[0] - 0.2, diag.deltas[-1] + 0.2)
plt.tight_layout()
plt.subplots_adjust(hspace=.0)
fig.align_ylabels(ax)
if not noplot:
plt.show()
def initUI(self):
self.driver_widget = Driver()
self.device_widget = Device(self.driver_widget)
self.about_widget = About()
self.settings_widget = Settings()
self.leakTest_widget = LeakTest()
self.diagram_widget = Diagram()
self.license_widget = License()
self.dwt_widget = DWT(self.driver_widget)
self.centralWidget = QMdiArea(self)
self.setCentralWidget(self.centralWidget)
self.sub1 = QMdiSubWindow()
self.sub1.setWidget(self.driver_widget)
self.centralWidget.addSubWindow(self.sub1)
self.sub1.show()
self.sub2 = QMdiSubWindow()
self.sub2.setWidget(self.device_widget)
self.centralWidget.addSubWindow(self.sub2)
self.sub2.show()
self.setWindowTitle("menu demo")
self.showMaximized()
self.setWindowTitle(self.title)
self.setGeometry(0, 0, self.width, self.height)
qtRectangle = self.frameGeometry()
centerPoint = QDesktopWidget().availableGeometry().center()
qtRectangle.moveCenter(centerPoint)
self.move(qtRectangle.topLeft())
mainMenu = self.menuBar()
mainMenu.setNativeMenuBar(False)
fileMenu = mainMenu.addMenu('File')
viewMenu = mainMenu.addMenu('View')
helpMenu = mainMenu.addMenu('Help')
saveButton = QAction('Save last configuration ...', self)
saveButton.setShortcut('Ctrl+S')
saveButton.triggered.connect(self.connectDevice)
fileMenu.addAction(saveButton)
loadButton = QAction('Load last configuration ...', self)
loadButton.setShortcut('Ctrl+L')
loadButton.triggered.connect(self.connectDevice)
fileMenu.addAction(loadButton)
connectButton = QAction('Connect to ...', self)
connectButton.setShortcut('Ctrl+C')
#connectButton.setStatusTip('Connect device')
connectButton.triggered.connect(self.connectDevice)
fileMenu.addAction(connectButton)
disconnectButton = QAction('Disconnect all', self)
disconnectButton.setShortcut('Ctrl+D')
#connectButton.setStatusTip('Connect device')
disconnectButton.triggered.connect(self.disconnectAll)
fileMenu.addAction(disconnectButton)
fileMenu.addSeparator()
exitButton = QAction('Exit', self)
exitButton.setShortcut('Ctrl+Q')
exitButton.setStatusTip('Exit application')
exitButton.triggered.connect(self.close)
fileMenu.addAction(exitButton)
diagramButton = QAction('Show diagram', self)
diagramButton.triggered.connect(self.openDiagram)
viewMenu.addAction(diagramButton)
leakTestButton = QAction('Leak test...', self)
leakTestButton.triggered.connect(self.openLeakTest)
viewMenu.addAction(leakTestButton)
settingsButton = QAction('Settings', self)
settingsButton.triggered.connect(self.openSettings)
viewMenu.addAction(settingsButton)
dwtButton = QAction('DWT', self)
dwtButton.triggered.connect(self.openDWT)
viewMenu.addAction(dwtButton)
"""
helpButton = QAction(QIcon('icon.png'), 'Help', self)
helpButton.setShortcut('Ctrl+H')
helpButton.setStatusTip('Help')
helpButton.triggered.connect(self.close)
helpMenu.addAction(helpButton)
"""
aboutButton = QAction(QIcon('icon.png'), 'About program', self)
aboutButton.setShortcut('Ctrl+A')
aboutButton.setStatusTip('About program')
aboutButton.triggered.connect(self.openAbout)
helpMenu.addAction(aboutButton)
licenseButton = QAction(QIcon('icon.png'), 'Licence info', self)
licenseButton.setShortcut('Ctrol+L')
licenseButton.setStatusTip('License inforamation')
licenseButton.triggered.connect(self.openLicense)
helpMenu.addAction(licenseButton)
self.statusBar().showMessage('DPI620 connected; PACE1000 connected')
"""
wid = QWidget(self)
self.setCentralWidget(wid)
grid = QGridLayout()
grid.setSpacing(10)
wid.setLayout(grid)
title = QLabel('Title')
author = QLabel('Author')
review = QLabel('Review')
titleEdit = QLineEdit()
authorEdit = QLineEdit()
reviewEdit = QTextEdit()
clearButton = QPushButton('Send', self)
grid.addWidget(title, 1, 0)
grid.addWidget(titleEdit, 1, 1)
grid.addWidget(author, 2, 0)
grid.addWidget(authorEdit, 2, 1)
grid.addWidget(review, 3, 0)
grid.addWidget(reviewEdit, 3, 1, 5, 1)
grid.addWidget(clearButton, 9, 1)
"""
# button.move(self.frameGeometry().width()-110, self.frameGeometry().height()-50)
self.setGeometry(0, 0, 800, 600)
qtRectangle = self.frameGeometry()
centerPoint = QDesktopWidget().availableGeometry().center()
qtRectangle.moveCenter(centerPoint)
self.move(qtRectangle.topLeft())
self.setWindowTitle('Calibri')
#self.setWindowIcon(QIcon('plus.gif'))
self.show()
def make_fast(self):
"""
Быстрая версия секторов, написанная на cython
"""
self.fast_diagram = Diagram(self.sectors)
def build(self):
return Diagram(self.__title, self.__services, self.__volumes,
self.__networks)
