asdeasoft.net

Code: Select all

from PyMpc import *
from PyMpc import MpcOdbVirtualResult as vr

App.clearTerminal() 
doc = App.postDocument() 

db = doc.getDatabase(1) 

result_names = ['Acceleration']
result_labels = [
	['Ax','Ay']]


R1 = db.getNodalResult(
	'Acceleration (Volumes',
	match=MpcOdb.StartsWith,
	time=vr.stageEnd(3)
	)
	
print(type(R1))

env_max = vr.max(R1)
env_min = vr.min(R1)

env_max.setDisplayName('(ENVmax) Acceleration')
env_max.setComponentLabels(['Ax','Ay'])

env_min.setDisplayName('(ENVmin) Acceleration')
env_min.setComponentLabels(['Ax','Ay'])

db.addVirtualResult(env_max)
db.addVirtualResult(env_min)

Code: Select all

env_max = vr.max(R1)

Code: Select all

env_max = vr.max(R1, R2)
env_min = vr.min(R1, R2)

Code: Select all

import numpy as np
from PyMpc import *
from PyMpc import MpcOdbVirtualResult as vr
from time import sleep
import traceback
from PySide2.QtCore import (
	QObject,
	Signal,
	Slot,
	QCoreApplication,
	QTimer,
	QThread,
	QEventLoop,
	QMutex,
	QMutexLocker,
	QWaitCondition,
	)
from PySide2.QtWidgets import (
	QWidget,
	QDialog,
	QSizePolicy,
	QVBoxLayout,
	QHBoxLayout,
	QProgressBar,
	)

# clear terminal
App.clearTerminal()

# get document
doc = App.postDocument()

# get first database
if len(doc.databases) == 0:
	raise Exception("You need a database with ID = 1 for this test")
db = doc.getDatabase(1)

# create evaluation options
# here we want to extract data for all steps of the last stage
all_stages = db.getStageIDs()
last_stage = all_stages[-1]
all_steps = db.getStepIDs(last_stage)
opt = MpcOdbVirtualResultEvaluationOptions()
opt.stage = last_stage

# create empty lists to store the maximum and minimum values for each node
env_max = []
env_min = []


class Worker(QObject):
	# signals
	finished = Signal()
	progress = Signal(int)
	# lengthy function
	@Slot()
	def run(self):
		try:
			# Nodal result
			NN = [6502] # list of nodes to process
			# calculate total number of nodes to process
			total_nodes = len(NN)
			# for each node
			for idx, node_id in enumerate(NN):
				# create empty list to store the acceleration values for this node
				acc_values = []
				# for each step
				for i in all_steps:
					opt.step = i
					# evaluate acceleration in x direction for this node
					field = db.getNodalResult("Acceleration", match=MpcOdb.Contains)
					acc_x = field[MpcOdbResultField.node(node_id), 0]
					# append the acceleration value to the list
					acc_values.append(acc_x)
				# calculate the maximum and minimum values for this node
				node_env_max = np.max(acc_values)
				node_env_min = np.min(acc_values)
				# append the maximum and minimum values to the respective lists
				env_max.append(node_env_max)
				env_min.append(node_env_min)
				# update progress bar
				self.progress.emit(int((idx + 1) / total_nodes * 100))

			# create virtual results
			max_vr = vr(env_max, 'Acceleration', ['Ax'], displayName='(ENVmax) Acceleration')
			min_vr = vr(env_min, 'Acceleration', ['Ax'], displayName='(ENVmin) Acceleration')

			# add virtual results to the database
			db.addVirtualResult(max_vr)
			db.addVirtualResult(min_vr)

		except Exception as ex:
			IO.write_cerr(str(ex))
		finally:
			self.finished.emit()
			
# create the thread, the worker, and move the worker to the thread
thread = QThread()
worker = Worker()
worker.moveToThread(thread)

# set up worker and thread connections
worker.finished.connect(thread.quit)
worker.finished.connect(worker.deleteLater)
thread.started.connect(worker.run)
thread.finished.connect(thread.deleteLater)

# create dialog
dialog = QDialog()
dialog.setWindowTitle("Processing nodes...")
#dialog.setWindowModality(2)
dialog.setFixedWidth(300)
dialog.setFixedHeight(100)
vbox = QVBoxLayout()
hbox = QHBoxLayout()
progress = QProgressBar()
hbox.addWidget(progress)
vbox.addLayout(hbox)
dialog.setLayout(vbox)

# create the thread, the worker,
# start the thread
thread.start()

# run dialog
dialog.exec_()

Code: Select all

from PyMpc import * 
from PyMpc import MpcOdbVirtualResult as vr
from time import sleep
import traceback
import numpy as np
from PySide2.QtCore import Qt, QObject, Signal, Slot, QThread, QEventLoop
from PySide2.QtWidgets import QDialog, QLabel, QProgressBar, QVBoxLayout, QApplication, QInputDialog
from numpy import genfromtxt
from numpy import argwhere
from numpy import sqrt

App.clearTerminal()

# get document
doc = App.postDocument()

# get first database
if len(doc.databases) == 0:
      raise Exception("You need a database with ID = 1 for this test")
db = doc.getDatabase(1)

# create evaluation options
# here we want to extract data for all steps of the last stage
all_stages = db.getStageIDs()
last_stage = all_stages[-1]
all_steps = db.getStepIDs(last_stage)
opt = MpcOdbVirtualResultEvaluationOptions()
opt.stage = last_stage
# for updating every n steps
num_steps = len(all_steps)

# initialization results
ACCELERATIONS_ENV_P = [];
# The worker class. It will run the lengthy function on a working thread
# and emit signals for calling the connected slots on the main thread
# Accelerations
acc = db.getNodalResult("Acceleration", match=MpcOdb.Contains)
		
class Worker(QObject):
	# signals
	finished = Signal()
	# lengthy function
	@Slot()
	def run(self):
		try:
		# forloop for all the nodes in the database
			for j in range(30): # Total number of nodes is 6502 but to save time I want to try with 30 nodes first.
				print(j+1)
				tmp = [];
				for i in range(1555, 1600, 1): #Total length = 8190, just taking the strongest part of signal.
					opt.step = all_steps[i];
					field = acc.evaluate(opt);
					row = MpcOdbResultField.node(j+1) # the node field object is the row identifier in the result field
					col = 0 # 0 = Ax, 1 = Ay, 2 = Az (the column 0-based index, depends on the result)
					AX = field[row, col];
					tmp.append(AX);
					AX = 0;
				ACCELERATIONS_ENV_P.append(max(tmp));         
		except Exception:
			IO.write_cerr(traceback.format_exc())
		finally:
			self.finished.emit()

# create an event loop that will block the script till the end
loop = QEventLoop()

# create the thread, the worker, and move the worker to the thread
thread = QThread()
worker = Worker()
worker.moveToThread(thread)

# set up worker and thread connections
worker.finished.connect(thread.quit)
worker.finished.connect(worker.deleteLater)
thread.started.connect(worker.run)
thread.finished.connect(thread.deleteLater)
thread.finished.connect(loop.quit)

# start the thread
thread.start()

# run event loop
loop.exec_()
print("DONE")

Code: Select all

D1 = db.getNodalResult("Acceleration", match=MpcOdb.Contains)
D1 = D1 + ACCELERATIONS_ENV_P;
D1.setDisplayName("Envelope Max")
D1.setComponentLabels(["Envelope Max"])
db.addVirtualResult(D1)