def __init__(self, extractions):
QWidget.__init__(self)
self.extractions = extractions
layout = QVBoxLayout()
self.setLayout(layout)
self.fig = plt.figure()
self.canvas = FigureCanvas(self.fig)
layout.addWidget(self.canvas)
self.graph = self.fig.add_subplot(111,
position=[0.15, 0.15, 0.75, 0.75])
if pms.DYNAMIC_TYPE == pms.DISCRETE:
self.graph.set_xlim(-1, pms.NOMBRE_PERIODES + 1)
self.graph.set_xlabel(trans_CO(u"Periods"))
self.graph.set_xticks(range(0, pms.NOMBRE_PERIODES + 1), 5)
curve_marker = "*"
elif pms.DYNAMIC_TYPE == pms.CONTINUOUS:
self.graph.set_xlim(
-5,
pms.CONTINUOUS_TIME_DURATION.total_seconds() + 5)
self.graph.set_xticks(
range(0,
int(pms.CONTINUOUS_TIME_DURATION.total_seconds()) + 1,
30))
self.graph.set_xlabel(trans_CO(u"Time (seconds)"))
curve_marker = ""
# curves
if self.extractions.curve is None:
self.extractions.curve, = self.graph.plot(self.extractions.xdata,
self.extractions.ydata,
"-k",
marker=curve_marker)
self.graph.set_ylim(-0.1, pms.DECISION_MAX + 0.1)
self.graph.set_yticks(np.arange(0, pms.DECISION_MAX + 0.1, 0.2))
self.graph.set_ylabel("")
self.graph.set_title(trans_CO(u"Extraction"))
self.graph.grid()
self.canvas.draw()
def __init__(self, payoffs):
super(PlotPayoff, self).__init__()
self.payoffs = payoffs
layout = QVBoxLayout()
self.setLayout(layout)
self.fig = plt.figure()
self.canvas = FigureCanvas(self.fig)
layout.addWidget(self.canvas)
self.graph = self.fig.add_subplot(111,
position=[0.15, 0.15, 0.75, 0.75])
if pms.DYNAMIC_TYPE == pms.DISCRETE:
self.graph.set_xlim(-1, pms.NOMBRE_PERIODES + 1)
self.graph.set_xlabel(trans_CO(u"Periods"))
self.graph.set_xticks(range(0, pms.NOMBRE_PERIODES + 1), 5)
curve_marker = "*"
elif pms.DYNAMIC_TYPE == pms.CONTINUOUS:
self.graph.set_xlim(
-5,
pms.CONTINUOUS_TIME_DURATION.total_seconds() + 5)
self.graph.set_xticks(
range(0,
int(pms.CONTINUOUS_TIME_DURATION.total_seconds()) + 1,
30))
self.graph.set_xlabel(trans_CO(u"Time (seconds)"))
curve_marker = ""
if self.payoffs.curve is None:
self.payoffs.curve, = self.graph.plot(self.payoffs.xdata,
self.payoffs.ydata,
"-k",
marker=curve_marker)
self.graph.set_ylim(0, 250)
self.graph.set_yticks(range(0, 271, 20))
self.graph.set_ylabel("")
self.graph.set_title(trans_CO(u"Part payoff"))
self.graph.grid()
self.canvas.draw()
def __init__(self, resource):
QWidget.__init__(self)
self.resource = resource
layout = QVBoxLayout()
self.setLayout(layout)
self.fig = plt.figure()
self.canvas = FigureCanvas(self.fig)
layout.addWidget(self.canvas)
self.graph = self.fig.add_subplot(111,
position=[0.15, 0.15, 0.75, 0.75])
if pms.DYNAMIC_TYPE == pms.DISCRETE:
self.graph.set_xlim(-1, pms.NOMBRE_PERIODES + 1)
self.graph.set_xlabel(trans_CO(u"Periods"))
self.graph.set_xticks(range(0, pms.NOMBRE_PERIODES + 1), 5)
curve_marker = "*"
elif pms.DYNAMIC_TYPE == pms.CONTINUOUS:
self.graph.set_xlim(
-5,
pms.CONTINUOUS_TIME_DURATION.total_seconds() + 5)
self.graph.set_xticks(
range(0,
int(pms.CONTINUOUS_TIME_DURATION.total_seconds()) + 1,
30))
self.graph.set_xlabel(trans_CO(u"Time (seconds)"))
curve_marker = ""
if self.resource.curve is None:
self.resource.curve, = self.graph.plot(self.resource.xdata,
self.resource.ydata,
"-k",
marker=curve_marker)
self.graph.set_ylim(0, pms.RESOURCE_INITIAL_STOCK * 3)
self.graph.set_yticks(range(0, pms.RESOURCE_INITIAL_STOCK * 3 + 1, 5))
self.graph.set_ylabel("")
self.graph.set_title(trans_CO(u"Available resource"))
self.graph.grid()
self.canvas.draw()
def _accept(self):
try:
self.timer_automatique.stop()
except AttributeError:
pass
val = self.slider_area.slider.value() / int(1 / pms.DECISION_STEP)
if not self.remote.le2mclt.automatique:
confirmation = QMessageBox.question(
self, "Confirmation", trans_CO(u"Do you confirm your choice?"),
QMessageBox.No | QMessageBox.Yes)
if confirmation != QMessageBox.Yes:
return
self.accept()
logger.info("send {}".format(val))
self.defered.callback(val)
def __init__(self, remote, defered):
super(GuiDecision, self).__init__(remote.le2mclt.screen)
# ----------------------------------------------------------------------
# main attributes
# ----------------------------------------------------------------------
self.remote = remote
self.defered = defered
layout = QVBoxLayout(self)
# ----------------------------------------------------------------------
# HEAD AREA
# ----------------------------------------------------------------------
layout_head = QHBoxLayout()
layout.addLayout(layout_head, 0)
if pms.DYNAMIC_TYPE == pms.DISCRETE:
self.label_period = QLabel(
le2mtrans(u"Period") +
u" {}".format(self.remote.currentperiod))
layout_head.addWidget(self.label_period, 0, Qt.AlignLeft)
self.compte_rebours = None
if pms.DYNAMIC_TYPE == pms.CONTINUOUS:
self.compte_rebours = WCompterebours(self,
pms.CONTINUOUS_TIME_DURATION,
lambda: None)
elif pms.DYNAMIC_TYPE == pms.DISCRETE:
time = timedelta(seconds=7) if self.remote.le2mclt.automatique else \
pms.DISCRETE_DECISION_TIME
self.compte_rebours = WCompterebours(self, time, self.send_extrac)
layout_head.addWidget(self.compte_rebours, 0, Qt.AlignLeft)
layout_head.addStretch()
# ----------------------------------------------------------------------
# GRAPHICAL AREA
# ----------------------------------------------------------------------
self.plot_layout = QGridLayout()
layout.addLayout(self.plot_layout)
# extraction
self.plot_extraction = PlotExtraction(self.remote.extractions)
self.plot_layout.addWidget(self.plot_extraction, 0, 0)
# part payoff
self.plot_payoff = PlotPayoff(self.remote.payoff_part)
self.plot_layout.addWidget(self.plot_payoff, 0, 1)
# available resource
self.plot_resource = PlotResource(self.remote.resource)
self.plot_layout.addWidget(self.plot_resource, 1, 0)
# value in text mode
widget_infos = QWidget()
widget_infos.setLayout(QVBoxLayout())
self.textEdit_infos = QTextEdit()
self.textEdit_infos.setReadOnly(True)
self.textEdit_infos.setHtml(self.remote.text_infos)
widget_infos.layout().addWidget(self.textEdit_infos)
self.plot_layout.addWidget(widget_infos, 1, 1)
self.plot_layout.setColumnStretch(0, 1)
self.plot_layout.setColumnStretch(1, 1)
# ----------------------------------------------------------------------
# DECISION AREA
# ----------------------------------------------------------------------
self.extract_dec = MySlider()
player_extrac = self.remote.extractions.ydata[-1]
self.extract_dec.slider.setValue(player_extrac * 100)
self.extract_dec.lcd.display(player_extrac)
layout.addWidget(self.extract_dec)
# ----------------------------------------------------------------------
# FOOT AREA
# ----------------------------------------------------------------------
self.setWindowTitle(trans_CO(u"Decision"))
if pms.DYNAMIC_TYPE == pms.CONTINUOUS:
self.extract_dec.slider.sliderReleased.connect(self.send_extrac)
if self.remote.le2mclt.automatique:
self.extract_dec.slider.valueChanged.connect(self.send_extrac)
self.timer_continuous = QTimer()
self.timer_continuous.timeout.connect(self.update_data_and_graphs)
self.timer_continuous.start(
int(pms.TIMER_UPDATE.total_seconds()) * 1000)
if pms.DYNAMIC_TYPE == pms.DISCRETE and self.remote.le2mclt.automatique:
self.extract_dec.slider.setValue(
random.randint(pms.DECISION_MIN,
pms.DECISION_MAX * int(1 / pms.DECISION_STEP)))
self.remote.end_of_time.connect(self.end_of_time)
def remote_update_data(self, player_extraction, the_time):
"""
called by the server:
- every second if dynamic == continuous
- every period if dynamic == discrete
:param player_extraction: the player's extraction
:param the_time: the time of the update
:return:
"""
# ----------------------------------------------------------------------
# we set the same time for every player in the group
# ----------------------------------------------------------------------
if self.currentperiod == 0:
xdata = 0
else:
if pms.DYNAMIC_TYPE == pms.DISCRETE:
xdata = self.currentperiod
elif pms.DYNAMIC_TYPE == pms.CONTINUOUS:
xdata = the_time
# ----------------------------------------------------------------------
# player extraction
# ----------------------------------------------------------------------
self.extractions.add_x(xdata)
self.extractions.add_y(player_extraction["CO_extraction"])
try:
self.extractions.update_curve()
except AttributeError:
pass
# ----------------------------------------------------------------------
# resource
# ----------------------------------------------------------------------
self.resource.add_x(xdata)
self.resource.add_y(player_extraction["CO_resource"])
# ----------------------------------------------------------------------
# cost
# ----------------------------------------------------------------------
self.cost.add_x(xdata)
self.cost.add_y(player_extraction["CO_cost"])
# ----------------------------------------------------------------------
# player payoff
# ----------------------------------------------------------------------
self.payoff_instant.add_x(xdata)
self.payoff_instant.add_y(player_extraction["CO_payoff"])
self.payoff_instant_discounted.add_x(xdata)
if pms.DYNAMIC_TYPE == pms.CONTINUOUS:
self.payoff_instant_discounted.add_y(
np.exp(-pms.param_r * xdata) * self.payoff_instant.ydata[-1])
else: # discrete
pass # todo: discounted payoff for discrete dynamic
cumulative_payoff = np.sum(self.payoff_instant_discounted.ydata)
infinite_payoff = pms.get_infinite_payoff(
xdata, player_extraction["CO_resource"],
player_extraction["CO_extraction"])
self.payoff_part.add_x(xdata)
self.payoff_part.add_y(cumulative_payoff + infinite_payoff)
# ----------------------------------------------------------------------
# update curves
# ----------------------------------------------------------------------
try:
self.extractions.update_curve()
self.resource.update_curve()
self.payoff_part.update_curve()
except AttributeError: # if period==0
pass
# ----------------------------------------------------------------------
# text information
# ----------------------------------------------------------------------
old = self.text_infos
the_time_str = texts_CO.trans_CO(u"Instant") if \
pms.DYNAMIC_TYPE == pms.CONTINUOUS else \
texts_CO.trans_CO(u"Period")
self.text_infos = the_time_str + u": {}".format(int(xdata)) + \
u"<br>" + texts_CO.trans_CO(u"Extraction") + \
u": {:.2f}".format(self.extractions.ydata[-1]) + \
u"<br>" + texts_CO.trans_CO(u"Available resource") + \
u": {:.2f}".format(self.resource.ydata[-1]) + \
u"<br>" + texts_CO.trans_CO(u"Instant payoff") + \
u": {:.2f}".format(self.payoff_instant.ydata[-1]) + \
u"<br>" + texts_CO.trans_CO(u"Discounted payoff") + \
u": {:.4f}".format(self.payoff_instant_discounted.ydata[-1]) + \
u"<br>" + texts_CO.trans_CO(u"Cumulative payoff") + \
u": {:.2f}".format(cumulative_payoff) + \
u"<br>" + texts_CO.trans_CO(u"Part payoff") + \
u": {:.2f}".format(self.payoff_part.ydata[-1])
self.text_infos += u"<br>{}<br>{}".format(20 * "-", old)
# ----------------------------------------------------------------------
# log
# ----------------------------------------------------------------------
logger.info("{} update data extraction: {:.2f} "
"resource: {:.2f} payoff: {:.2f}".format(
self.le2mclt, self.extractions.ydata[-1],
self.resource.ydata[-1], self.payoff_part.ydata[-1]))
def demarrer(self):
# ----------------------------------------------------------------------
# check conditions
# ----------------------------------------------------------------------
if not self.le2mserv.gestionnaire_graphique.question(
le2mtrans("Start") + " Control Optimal?"):
return
# ----------------------------------------------------------------------
# init part
# ----------------------------------------------------------------------
self.current_sequence += 1
self.current_period = 0
# __ creates parts ___
yield (self.le2mserv.gestionnaire_experience.init_part(
"controlOptimal",
"PartieCO",
"RemoteCO",
pms,
current_sequence=self.current_sequence))
self.all = self.le2mserv.gestionnaire_joueurs.get_players(
'controlOptimal')
# __ set parameters on remotes (has to be after group formation) __
yield (self.le2mserv.gestionnaire_experience.run_step(
le2mtrans(u"Configure"), self.all, "configure"))
# ----------------------------------------------------------------------
# SELECT THE INITIAL EXTRACTION
# ----------------------------------------------------------------------
self.le2mserv.gestionnaire_experience.run_func(self.all, "newperiod",
0)
yield (self.le2mserv.gestionnaire_experience.run_step(
trans_CO(u"Initial extraction"), self.all,
"set_initial_extraction"))
self.le2mserv.gestionnaire_experience.run_func(self.all, "update_data")
# ----------------------------------------------------------------------
# DEPENDS ON TREATMENT
# ----------------------------------------------------------------------
if pms.DYNAMIC_TYPE == pms.CONTINUOUS:
txt = le2mtrans(u"Period") + u" 1"
self.le2mserv.gestionnaire_graphique.infoserv(txt,
fg="white",
bg="gray")
self.le2mserv.gestionnaire_graphique.infoclt(txt,
fg="white",
bg="gray")
yield (self.le2mserv.gestionnaire_experience.run_func(
self.all, "newperiod", 1))
# __ timer continuous part __
QTimer.singleShot(
pms.CONTINUOUS_TIME_DURATION.total_seconds() * 1000 + 1000,
self.slot_time_elapsed)
time_start = datetime.now()
self.le2mserv.gestionnaire_graphique.infoserv(
"Start time: {}".format(time_start.strftime("%H:%M:%S")))
for j in self.all:
j.time_start = time_start
j.timer_update.start()
yield (self.le2mserv.gestionnaire_experience.run_step(
trans_CO("Decision"), self.all, "display_decision",
time_start))
elif pms.DYNAMIC_TYPE == pms.DISCRETE:
for period in range(1, pms.NOMBRE_PERIODES + 1):
if self.le2mserv.gestionnaire_experience.stop_repetitions:
break
# init period
txt = le2mtrans(u"Period") + u" {}".format(period)
self.le2mserv.gestionnaire_graphique.infoserv([txt],
fg="white",
bg="gray")
self.le2mserv.gestionnaire_graphique.infoclt([txt],
fg="white",
bg="gray")
yield (self.le2mserv.gestionnaire_experience.run_func(
self.all, "newperiod", period))
# decision
time_start = datetime.now()
yield (self.le2mserv.gestionnaire_experience.run_step(
"Decision", self.all, "display_decision", time_start))
self.le2mserv.gestionnaire_experience.run_func(
self.all, "update_data")
self.slot_time_elapsed()
# ----------------------------------------------------------------------
# summary
# ----------------------------------------------------------------------
yield (self.le2mserv.gestionnaire_experience.run_step(
le2mtrans(u"Summary"), self.all, "display_summary"))
# ----------------------------------------------------------------------
# End of part
# ----------------------------------------------------------------------
yield (self.le2mserv.gestionnaire_experience.finalize_part(
"controlOptimal"))