Result Objects#
- class SimulationResults#
Container object that encloses all the results from a single simulation. This object enables you to retrieve output states for Bodies, Requests and Rvs for each output time step.
There are two ways to instruct msolve to store the simulation results. In the
Model.simulate
method, one of the following must be set:- onOutputStep
Function that is called when the solver hits an output step. It can be used for animation and live plots.
- returnResults
Boolean that if True, causes SimulationResults to be populated.
- asDataFrame(start=0, end=None)#
Returns the runData object as a dictionary of Pandas dataframes. The keys of the dictionary are the objects whose results are stored.
- Parameters:
start (float) – Start time value for trimming each DataFrame.
end (float) – End time value for trimming each DataFrame.
- Returns:
A new dictionary where each value is the result of the
ResultObject.getDataFrame
method called on the original value.
- getObject(obj)#
Extracts the specified results from the SimulationResults (run) container and passes them into a
ResultObject
object.- Parameters:
obj (Body, Request, Rv, Name) – The object whose results are to be retrieved, or the unique name given to the object.
- Returns:
The
ResultObject
that is associated to the obj.
Note
Using the object as a lookup key is useful, so you don’t have to know the name of the object. This approach allows for convenient lookups without relying on object names.
Using the name string as a lookup key is advantageous in scenarios such as plot templates or when working with serialized data in formats like pickle files. In such cases, the model instance and its associated objects may not be directly accessible, making the use of objects impractical. Using the name string allows for reliable lookups even when the object hierarchy is not available.
- serialize_json(filename=None, zip_flag=False)#
Serializes the SimulationResults resultObjects dict object to JSON. If a filename is provided, the data is written to a JSON file or a zip file based on the zip_flag.
If zip_flag is True, a temporary JSON file is created, written, and then compressed into a zip file. The temporary file is deleted after compression. If zip_flag is False, the JSON data is written directly to the specified file.
If no filename is specified, the method returns a JSON string.
- serialize_pickle(filename=None, serialize_all=False)#
Pickles the SimulationResults object. If filename is specified, the data is written to a pickle file. If not, the method returns a pickle string.
If serialize_all=False, only the tagged (named) result objects will be serialized. This is done for memory saving purposes.
- showSummary()#
- Prints a rich summary tree.
The output contains results and component hierarchy extracted from this object with color-coded output for improved readability. Example:
from msolve import * model = createDemoPendulum() run = model.simulate(type="TRANSIENT", end=1, steps=100, returnResults=True) run.showSummary()
Warning
This functionality requires the ‘rich’ library to be installed.
- class SimulationResultsHistory(**kwds)#
A list that can be used to store, serialize and de-serialize SimulationResults for cross plotting. Any simulation executed with the flag store=True will append an instance of the current
SimulationResults
to this class. The SimulationResultsHistory is stored as part of the model.Example
from msolve import * model = createDemoPendulum() # run two simulations, each will be stored. model.simulate(type="TRANSIENT", end=1, steps=100, store=True) model.simulate(type="TRANSIENT", end=5, steps=1000, store=True) # print each node in the list as a Pandas DataFrame for run in model.simulationResultsHistory: print(run.asDataFrame())
- serialize_json(filename=None)#
Serializes the SimulationResultsHistory to JSON. If a filename is provided, the data is written to a JSON file. If not, the method returns a JSON string.
- serialize_pickle(filename=None, serialize_all=False)#
Pickles the SimulationResultsHistory object. If filename is defined, the data is written to a pkl file. If not, the method returns a pickle string. If serialize_all=False, only the tagged (named) result objects will be serialized. This is done for memory saving purposes.
- class ResultObject#
Base class for all the result objects of a simulation. The methods of this class are the access point to the numerical data of the simulation results.
- getComponent(component)#
Queries a ResultObject and returns the time history of a specific component of the object. The components can be indexed with their index number or their respective label.
The available components for each object are listed in
BodyResult
,FlexBodyResult
,PointMassResult
,RequestResult
,RvResult
,FrfBodyResult
,FrfRequestResult
.
- getDataFrame()#
The entire ResultObject corresponding to the owner is returned as a Pandas DataFrame. It contains all the components and uses labels as column names.
Useful Pandas DataFrame functionalities:
- df.info()
Prints concise summary of the DataFrame.
- df.describe()
Generates descriptive statistics for all columns including min, std, max, mean.
- df[‘column_name’] or df.column_name
Returns the column with name ‘column_name’ as a pandas Series.
- df.columns
Prints a pandas index corresponding to all the columns.
- getStep(step=-1)#
Queries a ResultObject and returns its data for the specific time step or the closest previous step. step can be an integer or a float value corresponding to the time step.
- class BodyResult#
Contains all the results associated with a single Part of the model.
At each output time, the following results are stored:
Components
Label
Index
Local Part Reference Frame (LPRF) position
X, Y, Z
0 - 2
Euler parameters
E0, E1, E2, E3
3 - 6
Example
Extract the simulation results of a Body with getComponent.#from msolve import * model = Model(output='body_results') Units(system='MKS') Accgrav(kgrav=-9.81) ground = Part(ground=True) global_ref = Marker(part=ground) ball = Part(mass=1, ip=[1]*3, cm=Marker(qp=[0,0,10], zv=[0,0,1])) run = model.simulate(type='TRANSIENT', end=2, dtout=0.01, returnResults=True) body_results = run.getObject(ball) #assert type(body_results) == BodyResult time = body_results.times ball_disp = body_results.getComponent('Z') import matplotlib.pyplot as plt plt.plot(time, ball_disp) plt.title('Vertical Displacement') plt.xlabel('time (s)') plt.ylabel('z (m)') plt.grid() plt.show()
- class FrfBodyResult#
- Frequency Response Simulation results for body.
Contains all the results associated with a single Part of the model in a FrequencyResponse simulation for Rigid, Flexible and PointMass bodies.
When performing a Frequency Response Analysis, at each output time, the following results are stored:
Components
Label
Index
Local Part Reference Frame Results
X_MAG, X_PHASE, Y_MAG, Y_PHASE, Z_MAG, Z_PHASE
0 - 5
- class FlexBodyResult#
Contains results associated with a single FlexBody of the model.
At each output time, the following results are stored:
Components
Label
Index
Center of mass position
X, Y, Z
0 - 2
Euler parameters
E0, E1, E2, E3
3 - 6
Center of mass velocities
VX, VY, VZ, WX, WY, WZ
7 - 12
Center of mass accelerations
ACCX, ACCY, ACCZ, WDTX, WDTY, WDTZ
13 - 18
Modal participation factors
Q1, …. , QN
19 - (18+nmodes)
Strain Energy
SE
19+nmodes
Example
For this example, a mtx file is required. The file is located in the mbd_modeling\flexbodies folder in the MotionSolve tutorials Model Files. You may copy the file to your working directory.
Extract the simulation results of a FlexBody with asDataFrame().#from msolve import * model = Model(output='flex_results') ground = Part(ground=True) global_ref = Marker(part=ground) Units(system='MKS') Accgrav(kgrav=-9.81) flex = FlexBody(mtx_file="sla_flex_left.mtx", qg=[0,0,4]) flex_marker = Marker(flex_body=flex, qp=flex.qg, zv=[0,0,1]) vel_request = Request(type="VELOCITY", i=flex_marker, j=global_ref) run = model.simulate (type="DYNAMIC", end=0.5, steps=500, returnResults=True) results_dict = run.asDataFrame() print(results_dict.keys()) flex_df = results_dict[flex] vel_request_df = results_dict[vel_request] print(vel_request_df.columns) import matplotlib.pyplot as plt plt.plot(flex_df['Z'], label="flex cm z-displacement") plt.plot(abs(vel_request_df['VZ']), label="flex lprf z-velocity") plt.xlabel('time (s)') plt.legend() plt.grid() plt.show()
- class PointMassResult#
Contains all the results associated with a single PointMass of the model.
At each output time, the following results are stored:
Components
Label
Index
LPRF position
X, Y, Z
0 - 2
Example
Extract the simulation results of a PointMass with getStep().#from msolve import * model = Model(output='pmass_results') Units(system='MKS') Accgrav(kgrav=-9.81) ground = Part(ground=True) global_ref = Marker(part=ground) pmass = PointMass(mass=10, cm=Marker(qp=[0,0,10], zv=[0,0,1]), vz=8.0) run = model.simulate(type='DYNAMIC', end=2, dtout=0.01, returnResults=True) pmass_results = run.getObject(pmass) #assert type(pmass_results) == PointMassResult time = pmass_results.times import matplotlib.pyplot as plt # loop over the number of output time steps for i in range(1,200): pmass_disp = pmass_results.getStep(i)[2] plt.scatter(i*0.01, pmass_disp, linewidths=1.0) plt.title('Vertical Displacement') plt.xlabel('time (s)') plt.ylabel('z (m)') plt.grid() plt.show()
- class RequestResult#
Contains all the results associated with a single Request of the model.
At each output time, the following results are stored:
Components
Label
Index
Displacement Request
MAG, X, Y, Z, null, PSI, THETA, PHI
0 - 7
Velocity Request
VM, VX, VY, VZ, WM, WX, WY, WZ
0 - 7
Acceleration Request
ACCM, ACCX, ACCY, ACCZ, WDTM, WDTX, WDTY, WDTZ
0 - 7
Force Request
FM, FX, FY, FZ, TM, TX, TY, TZ
0 - 7
Expression Request
F1, F2, F3, F4, F5, F6, F7, F8
0 - 7
Example
Extract the simulation results of a Request with getDataFrame().#from msolve import * model = Model(output='request_results') Units(system='mmks') Accgrav(kgrav=-9.81) ground = Part(ground=True) global_ref = Marker(part=ground) part = Part(mass=10, ip=[1e3]*3, cm=Marker(qp=[0,0,10], zv=[0,0,1])) spdp = SpringDamper(type = 'TRANSLATION', i = part.cm, j = global_ref, k = 0.05, c = 0.005, force = 50, length = 10, ) vel_request = Request(type='VELOCITY', i=part.cm, j=global_ref) acc_request = Request(f1=f'ACCZ({part.cm.id},{global_ref.id})') run1 = model.simulate(type='DYNAMIC', end=5, dtout=0.01, returnResults=True) spdp.c = 0.05 run2 = model.simulate(type='DYNAMIC', end=8, dtout=0.01, returnResults=True) vel_results = run1.getObject(vel_request) acc_results = run1.getObject(acc_request) df = vel_results.getDataFrame() df.columns time = acc_results.times acceleration = acc_results.getComponent('F1') import matplotlib.pyplot as plt plt.plot(df.VZ) plt.plot(time, acceleration) plt.title('Part Velocity & Acceleration time-histories') plt.legend(['Velocity', 'Acceleration']) plt.xlabel('time (s)') plt.grid() plt.show()
- class FrfRequestResult(**kwds)#
Contains all the results associated with a single Request of the model for a FrequencyResponse analysis.
When performing a Frequency Response Analysis, at each output time, the following results are stored:
Components
Label
Index
Displacement Request
X_MAG, X_PHASE, Y_MAG, Y_PHASE, Z_MAG, Z_PHASE, B1_MAG, B1_PHASE, B2_MAG, B2_PHASE, B3_MAG, B3_PHASE
0 - 11
Velocity Request
VX_MAG, VX_PHASE, VY_MAG, VY_PHASE, VZ_MAG, VZ_PHASE, WX_MAG, WX_PHASE, WY_MAG, WY_PHASE, WZ_MAG, WZ_PHASE
0 - 11
Acceleration Request
ACCX_MAG, ACCX_PHASE, ACCY_MAG, ACCY_PHASE, ACCZ_MAG, ACCZ_PHASE, WDTX_MAG, WDTX_PHASE, WDTY_MAG, WDTY_PHASE, WDTZ_MAG, WDTZ_PHASE
0 - 11
Force Request
FX_MAG, FX_PHASE, FY_MAG, FY_PHASE, FZ_MAG, FZ_PHASE, TX_MAG, TX_PHASE, TY_MAG, TY_PHASE, TZ_MAG, TZ_PHASE
0 - 11
- class RvResult#
Contains all the results associated with a single Rv of the model.
At each output time, the following results are stored:
Components
Label
Index
Value of the integral of the Rv
RVAL
0
Value of the Rv
RVAL1
1
Example
Extract the simulation results of a Response variable (Rv).#from msolve import * model = Model(output='rv_results') ground = Part(ground=True) global_ref = Marker(part=ground) Units(system='mks') Accgrav(kgrav=-10) part = Part(mass=100, ip=[1,1,1], cm = Marker(qp=[0,0,1])) c = Dv (b=0.1, blimit=[0.01, 1]) spdp = SpringDamper (type="TRANSLATION", i=part.cm, j=global_ref, k=1, c=c) rv = Rv(function=f"DZ({part.cm.id})") run = model.simulate(type="STATIC", end=0.5, steps=20, returnResults=True, dsa='AUTO') rv_output = run.getObject(rv) time = rv_output.times rv_rval = rv_output.getComponent('RVAL') rv_rval1 = rv_output.getComponent('RVAL1') import matplotlib.pyplot as plt plt.plot(time, rv_rval, label="rval") plt.plot(time, rv_rval1, label="rval1") plt.xlabel('time (s)') plt.legend() plt.grid() plt.show()