| TRICK 7 TO TRICK 10 INPUT FILE DIFFERENCES KEY : |  |  |  |
| Bold = Default behavior |  |  |  |
| Green = New Trick 10 feature or implementation is different than Trick 7 |  |  |  |
| Blue = Need a Trick 10 interface routine |  |  |  |
| Orange = Not implemented in Trick 10 / presumably not needed |  |  |  |
| Red Bold = Not implemented in Trick 10 / needs to be fixed |  |  |  |
SPECIAL SYNTAX TRICK 7 | TRICK 10 | DESCRIPTION |  |  |
#include "S_default.dat" | N/A : include any default data files in your S_define header | INCLUDE DEFAULT DATA |  |  |
#include "<myother_inputfile>" | import <myother_inputfile> OR execfile("<myother_inputfile>") | INCLUDE ANOTHER INPUT FILE |  |  |
call <simobj>.<funcname>(<params>) ; | <simobj>.<funcname>(<params>) | CALL A SCHEDULED C FUNCTION |  |  |
call <simobj>.<simobj>.<obj>.<funcname>(<params>) ; | <simobj>.<obj>.<funcname>(<params>) | CALL A SCHEDULED C++ FUNCTION |  |  |
checkpoint ; | trick.checkpoint() | CHECKPOINT SIM NOW |  |  |
| trick.load_checkpoint("<checkpoint_filename>") | LOAD A CHECKPOINT FILE NOW |  |  |
checkpoint += <sec> ; | trick.checkpoint(trick.exec_get_sim_time() + <sec>) | CHECKPOINT SIM <sec> SECONDS FROM NOW |  |  |
checkpoint = <sec> ; | trick.checkpoint(<sec>) | CHECKPOINT SIM AT TIME <sec> |  |  |
checkpoint <simobjname> [= <sec>] ; | trick.checkpoint_objects("<checkpoint_filename>","<object>[,<object>,É]") | CHECKPOINT A SIM OBJECT NOW [OR AT TIME <sec> TRICK7 ONLY] |  |  |
cycle <jobname> = <sec> ; | trick.exec_set_job_cycle("<jobname>", <instance>, <sec>) | SET CYCLE TIME OF JOB |  |  |
echo On|Off ; | trick.echo_jobs_on() OR trick.echo_jobs_off() | ECHO NAMES OF CALLED JOBS DURING EXECUTION |  |  |
echo_on ; echo_off ; | NOT IMPLEMENTED | ECHO INPUT FILE AS IT IS PARSED |  |  |
freeze ; | trick.freeze() | FREEZE SIM NOW |  |  |
freeze += <sec> ; | trick.freeze(trick.exec_get_sim_time() + <sec>) | FREEZE SIM <sec> SECONDS FROM NOW |  |  |
freeze = <sec> ; | trick.freeze(<sec>) | FREEZE SIM AT TIME <sec> |  |  |
job <jobname> = On|Off ; | trick.exec_set_job_onoff("<jobname>", <instance>, True|False) | ENABLE/DISABLE RESCHEDULING OF JOB |  |  |
pause ; | raw_input("Input Processor Paused. Hit <enter> to continue") | STOP PROCESSING INPUT UNTIL USER HITS <ENTER> |  |  |
read += <sec> ; | trick.add_read(trick.exec_get_sim_time() + <sec>, "<statements>") | READ FOLLOWING STMTS <sec> SECONDS FROM NOW |  |  |
read = <sec> ; | trick.add_read(<sec>, "<statements>") | READ FOLLOWING STMTS AT TIME <sec> |  |  |
send_hs(<FILE>, "<message_text>") ; | trick.send_hs(None, "<message_text>") | SEND A HEALTH & STATUS MSG TO SIM CONTROL PANEL (IN TRICK10 MSG ALSO GOES TO STDOUT) |  |  |
sim_object <simobjname> = On|Off ; | trick.exec_set_sim_object_onoff("<simobjname>", True|False) | ENABLE/DISABLE RESCHEDULING OF ALL JOBS IN SIM_OBJECT |  |  |
stop ; | trick.stop() | TERMINATE SIM NOW |  |  |
stop += <sec> ; | trick.stop(trick.exec_get_sim_time() + <sec>) | TERMINATE SIM 5 SECONDS FROM NOW |  |  |
stop = <sec> ; | trick.stop(<sec>) | TERMINATE SIM AT TIME <sec> |  |  |
<my_int_ptr> = alloc(5) ; | <my_int_ptr> = trick.alloc_type(5, "int") OR <my_int_ptr> = trick.TMM_declare_var_s("int[5]") OR <my_int_ptr> = trick.TMM_declare_var_1d("int", 5) | DYNAMICALLY ALLOCATE DATA |  |  |
<my_string> = "${<env_varname>}" | getenv("<env_varname>") ; | <my_string> = os.getenv("<env_varname>") | ACCESS ENVIRONMENT VARIABLE |  |  |
<simobj>.<var> {<unit>} = <val> ; | <simobj>.<var> = trick.attach_units("<unit>", <val>) | VARIABLE ASSIGNMENT WITH UNITS |  |  |
if (<simobj>.<var> == <val>) É | if (trick.detach_units(<simobj>.<var>) == <val>) ... | VARIABLE COMPARISON (TRICK10: MUST REMOVE UNITS) |  |  |
EVENTS / MALFUNCTIONS TRICK 7 | TRICK 10 | DESCRIPTION |  |  |
begin_event <event_name> { | <event_name> = trick.new_event("<event_name>") | DECLARE AN EVENT |  |  |
condition : <variable|val> <logic_op>|trip: <variable|val> [slope: +|-] [tolerance: <val>] ; | <event_name>.condition(<index>, "<input text string>") (trip, slope, tolerance NOT IMPLEMENTED) | EVENT CONDITION (AT LEAST 1 IS REQUIRED) |  |  |
[condition: ... ;] | [<event_name>.condition(<index+1>, "<input text string>")] | ADDITIONAL CONDITION(S) |  |  |
action { <any legal input statements> } | <event_name>.action(<index>, "<input text string>") | EVENT ACTION (ONLY 1 IN TRICK7; AT LEAST 1 IN TRICK10) |  |  |
| [<event_name>.action(<index+1>, "<input text string>")] | ADDITIONAL ACTION(S) |  |  |
[dt = 1.0|<sec> ;] | <event_name>.set_cycle(1.0|<sec>) | EVENT CYCLE TIME |  |  |
[priority = <val> ;] | NOT IMPLEMENTED | EVAL PRIORITY OF EVENT WITH RESPECT TO OTHER EVENTS AT SAME TIME |  |  |
[active = On|Off ;] | <event_name>.activate() OR <event_name>.deactivate() | ACTIVATE/DEACTIVATE EVENT EVALUATION |  |  |
[group = all | any <num> ;] | <event_name>.condition_any() (<num>=1 only!) OR <event_name>.condition_all() | HOW TO EVALUATE MULTIPLE EVENT CONDITIONS (TRICK7: FOR "ANY", YOU CAN SPECIFY <num> CONDITIONS TO THAT MUST BE TRUE; TRICK10: <num> IS 1 FOR THE "ANY" CASE.) |  |  |
} ; // end of event | trick.add_event(<event_name>) | END EVENT AND ADD IT TO TRICK'S LIST OF EVENTS |  |  |
begin malfunction <malf_name> { | <malf_name> = trick.new_event("<malf_name>") | DECLARE A MALFUNCTION (IMPLEMENTED AS EVENT IN TRICK10) |  |  |

trigger {
condition: <syntax same as event>
|job: <malfunction_trigger_jobname> ;
insert_before|insert_after: <job_name> ;
hold: On|Off ;
}

<malf_name>.condition(<index>, "<input text string>") OR
<malf_name>.condition_job(<index>, "<job name>") OR
<malf_name>.condition_var(<index>, "<variable name>")
<malf_name>.condition_hold_on(<index>) OR
<malf_name>.condition_hold_off(<index>)
insertion is done for whole event, not per trigger or action: see below

MALFUNCTION "TRIGGER" CONDITION OR JOB (AT LEAST 1 REQUIRED)
HOLD OPTION TO KEEP CONDITION TRUE WHEN IT BECOMES TRUE

[trigger { ... }] | [<malf_name>.condition(<index+1>, "<input text string>") OR <malf_name>.condition_job(<index+1>, "<job name>") OR <malf_name>.condition_var(<index+1>, "<variable name>")] | ADDITIONAL MALFUNCTION TRIGGER CONDITION(S) |  |  |

action {
insert_before|insert_after: <job_name> ;
<any legal input statements>
}
|<variable> {
insert_before|insert_after: <job_name> ;
[values: <new_value> ;]
[scale_factor: <scale_value> ;]
[bias: <bias_value> ;]
[units: {<units>} ;]
}
|call <malfunction_jobname> before|after <job_name> ;
|job <job_name> On|Off ;

<malf_name>.action(<index>, "<input text string>") OR
<malf_name>.action_job(<index>, "<job name>") OR
<malf_name>.action_job_on(<index>, "<job name>") OR
<malf_name>.action_job_off(<index>, "<job name>")
(use rti_add/rti_fire to set variables -- see below)
insertion is done for whole event, not per trigger or action: see below

MALFUNCTION ACTION

[action {É}|<variable {É}|callÉ|jobÉ] | [<malf_name>.action(<index+1>, "<input text string>") OR <malf_name>.action_job(<index+1>, "<job name>"] | ADDITIONAL MALFUNCTION ACTION(S) |  |  |
} ; // end of malfunction | trick.add_event(<malf_name>) OR trick.add_event_before(<malf_name>, "<job_name>") OR trick.add_event_after(<malf_name>, "<job_name>") | END MALFUNCTION (TRICK10: INSERT IT IN JOB QUEUE AT TOP FRAME, OR BEFORE A JOB, OR AFTER A JOB) |  |  |
edit malfunction <malf_name> { É } | <malf_name>.action... OR <malf_name>.condtion... | CHANGE PART(S) OF A MALFUNCTION |  |  |
delete malfunction <malf_name> ; | trick.delete_event(<malf_name>) | DELETE A MALFUNCTION |  |  |
malfunction_cmd <malf_name> disable_trigger ; OR malfunction_cmd <malf_name> enable_trigger ; | <malf_name>.condition_disable(<index>) OR <malf_name>.condition_enable(<index>) | DISABLE/ENABLE MALFUNCTION TRIGGER EVALUATION (TRICK7: ALL OR NONE, TRICK10: SETTABLE PER TRIGGER) |  |  |
| <malf_name>.action_disable(<index>) OR <malf_name>.action_enable(<index>) | DISABLE/ENABLE MALFUNCTION ACTION |  |  |
malfunction_cmd <malf_name> manual_on ; | <malf_name>.manual_on() | MANUALLY SET MALFUNCTION AS FIRED/HOLD ON: ACTIONS RUN EACH CYCLE |  |  |
| <malf_name>.manual_fire() | MANUALLY SET MALFUNCTION AS FIRED: ACTIONS RUN ONCE NOW |  |  |
malfunction_cmd <malf_name> manual_off ; | <malf_name>.manual_off() | MANUALLY SET MALFUNCTION AS NOT FIRED: ACTIONS WILL NOT RUN |  |  |
malfunction_cmd <malf_name> remove_manual ; | <malf_name>.manual_done() | EXIT MANUAL MODE FOR THIS MALFUNCTION, RETURN TO NORMAL EVAL |  |  |
| trick.rti_add_int("<variable name>", <val>) OR trick.rti_add_float("<variable name>", <val>) | ADD NEW VARIABLE VALUES TO A TRICK INTERNAL QUEUE, TO BE "INJECTED" INTO THE SIM WITH RTI_FIRE(). |  |  |
| trick.rti_fire() | SET ALL SIM VARIABLES THAT WERE RTI_ADDED TO THEIR NEW VALUES, OCCURS AT TOP OF NEXT FRAME BEFORE ANY OTHER JOBS ARE STARTED SO THE VARIABLE SETTINGS ARE THREAD SAFE. |  |  |
SYS EXEC IN TRICK 7 | TRICK 10 | DESCRIPTION |  |  |
sys.exec.in.attach_debugger = Yes|No ; | trick.exec_set_attach_debugger(True|False) | ATTACH DEBUGGER IN CASE OF SEG FAULT (LINUX ONLY) |  |  |
sys.exec.in.checkpoint_cpu_number = <n> ; | trick.checkpoint_cpu(<n>) | USE CPU # <n> FOR CHECKPOINT CHILD JOB |  |  |
sys.exec.in.debugger_command = "/usr/bin/gdb|<mydebugger>" ; | trick.exec_set_debugger_command("/usr/bin/gdb|<mydebugger>") | THE DEBUGGER COMMAND |  |  |
sys.exec.in.echo_job = Yes|No ; | trick.echo_jobs_on() OR trick.echo_jobs_off() | ECHO NAMES OF CALLED JOBS DURING EXECUTION |  |  |
sys.exec.in.enable_cpu_stats = Yes|No ; | NOT IMPLEMENTED | PRINT RUNTIME CPU & MEMORY USAGE STATS AT SHUTDOWN |  |  |
sys.exec.in.enable_freeze = Yes|No ; | trick.exec_set_enable_freeze(True|False) | ENABLE CTRL-C FREEZE MODE TOGGLING |  |  |
sys.exec.in.enable_init_stepping = Yes|No ; | NOT IMPLEMENTED | ENABLE INITIALIZATION JOB PHASE STEPPING IN SIM CONTROL PANEL |  |  |
sys.exec.in.enable_var_server = Yes|No ; | trick.set_var_server_enabled(True|False) | ENABLE THE VARIABLE SERVER |  |  |
sys.exec.in.end_checkpoint = Yes|No ; | trick.checkpoint_end(True|False) | DUMP CHECKPOINT AT SHUTDOWN |  |  |
sys.exec.in.frame_log = Yes|No ; | trick.frame_log_on() OR trick.fame_log_off() | RECORD JOB TIMING INFO FOR EACH REALTIME FRAME |  |  |
sys.exec.in.frame_log_max_samples = 1000|<n> ; | trick.frame_log_set_max_samples = 100000|<n> | ONLY RECORD MAX OF <n> JOB TIMING SAMPLES |  |  |
sys.exec.in.frame_log_start_time = 0.0|<sec> ; | NOT IMPLEMENTED; use frame_log_on/frame_log_off with read | SIM TIME TO START JOB TIMING SAMPLES |  |  |
sys.exec.in.freeze_cycle = 0.9999|<sec> ; | trick.exec_set_freeze_frame(1.0|<sec>) | FREEZE JOB CYCLE TIME |  |  |
sys.exec.in.gmt_ref.day = 0|<n> ; | NOT IMPLEMENTED | GMT DAY SHOWN IN SIM CONTROL PANEL |  |  |
sys.exec.in.gmt_ref.hour = 0|<n> ; | NOT IMPLEMENTED | GMT HOUR SHOWN IN SIM CONTROL PANEL |  |  |
sys.exec.in.gmt_ref.min = 0|<n> ; | NOT IMPLEMENTED | GMT MINUTE SHOWN IN SIM CONTROL PANEL |  |  |
sys.exec.in.gmt_ref.sec = 0.0|<n> ; | NOT IMPLEMENTED | GMT SECOND SHOWN IN SIM CONTROL PANEL |  |  |
sys.exec.in.hexflt_checkpoint = Yes|No ; | trick.TMM_hexfloat_checkpoint(True|False) | PUT FLOATS/DOUBLES IN HEX FORMAT WHEN CHECKPOINTING TO PRESERVE PRECISION |  |  |
sys.exec.in.met_ref.day = 0|<n> ; | NOT IMPLEMENTED | MET DAY SHOWN IN SIM CONTROL PANEL |  |  |
sys.exec.in.met_ref.hour = 0|<n> ; | NOT IMPLEMENTED | MET HOUR SHOWN IN SIM CONTROL PANEL |  |  |
sys.exec.in.met_ref.min = 0|<n> ; | NOT IMPLEMENTED | MET MINUTE SHOWN IN SIM CONTROL PANEL |  |  |
sys.exec.in.met_ref.sec = 0.0|<n> ; | NOT IMPLEMENTED | MET SECOND SHOWN IN SIM CONTROL PANEL |  |  |
sys.exec.in.mtv = Yes|No ; | trick.malfunctions_trick_view_set_enabled(True|False) | START TRICK MTV AUTOMATICALLY |  |  |
sys.exec.in.output_dir_timestamped = Yes|No ; | trick.output_dir_timestamped_on() OR trick.output_dir_timestamped_off() | SAVE RUN DATA FILES IN SUBDIR DATA_<time> |  |  |
sys.exec.in.post_init_checkpoint = Yes|No ; | trick.checkpoint_post_init(True|False) | DUMP CHECKPOINT AFTER INITIALIZATION JOBS RUN |  |  |
sys.exec.in.pre_init_checkpoint = Yes|No ; | trick.checkpoint_pre_init(True|False) | DUMP CHECKPOINT BEFORE INITIALIZATION JOBS RUN |  |  |
sys.exec.in.reduced_checkpoint = Yes|No ; | trick.TMM_reduced_checkpoint(True|False) | ONLY DUMP NON-ZERO VALUES AT CHECKPOINT |  |  |
sys.exec.in.rt_clock = Gettimeofday|GMT|EXTERNAL ; | N/A : derive your class from Trick's Clock class (see GetTimeOfDayClock) | REALTIME CLOCK OPTION |  |  |
sys.exec.in.rt_clock_ratio = 1.0|<sec> ; | real_time.gtod_clock.rt_clock_ratio = 1.0|<sec> | SIMULATION EXECUTION SPEED WRT REALTIME |  |  |
sys.exec.in.rt_cpu_number[<id>] = 0|<n> ; sys.exec.in.rt_lock_to_cpu[<id>] = Yes|No ; | trick.exec_set_thread_cpu_affinity(<id>, <n>) | RUN PROCESS <id> ONLY ON CPU # <n> |  |  |
sys.exec.in.rt_enable_clock_reset = Yes|No ; | NOT IMPLEMENTED | AUTOMATICALLY ADJUST CLOCK WHEN ITIMERS USED (PRIOR TO LINUX 2.6) |  |  |
sys.exec.in.rt_exttimer = Yes|No ; | N/A : derive your class from Trick's Timer class (see ITimer) | ALLOW EXTERNAL TIMER INTERRUPTS TO CONTROL REALTIME |  |  |
sys.exec.in.rt_isolate_proc[<id>] = Yes|No ; | NOT IMPLEMENTED | ISOLATE PROCESS <id>'s CPU FROM OTHER INTERRUPTS/PROCESSES |  |  |
sys.exec.in.rt_itimer = Yes|No ; sys.exec.in.rt_itimer_pause = Yes|No ; | trick.itimer_enable() OR trick.itimer_disable() | TURN ITIMER ON AND USE PAUSE() |  |  |
sys.exec.in.rt_itimer_frame {s} = 1.0e37|<sec> ; | N/A : it is set to same as rt_software_frame | ITIMER FRAME: DELTA TIME BETWEEN ITIMER SIGNALS |  |  |
sys.exec.in.rt_lock_memory[<id>] = Yes|No ; | trick.exec_set_lock_memory(True|False) | LOCK PROCESS <id> IN MEMORY (NOTE NO <id> IN TRICK 10, ALL LOCKED) |  |  |
sys.exec.in.rt_max_overrun_cnt = 100000000|<n> ; | real_time.rt_sync.rt_max_overrun_cnt = 100000000|<n> | MAX CONSECTUTIVE OVERRUNS ALLOWED BEFORE SHUTDOWN |  |  |
sys.exec.in.rt_max_overrun_time = 1.0e37|<sec> ; | real_time.rt_sync.rt_max_overrun_time = 1.0e37|<sec> | MAX OVERRUN TIME PER ANY FRAME BEFORE SHUTDOWN |  |  |
sys.exec.in.rt_nap = Yes|No ; | trick.exec_set_rt_nap(True|False) | RELEASE PROCESSOR WHEN WAITING FOR REALTIME OR CHILDREN |  |  |
sys.exec.in.rt_overrun_freeze = Yes|No ; | real_time.rt_sync.rt_overrun_freeze = True|False | FREEZE INSTEAD OF SHUTDOWN WHEN MAX OVERRUN CNT/TIME |  |  |
sys.exec.in.rt_priority[<id>] = 20|<n> ; sys.exec.in.rt_nond_pri[<id>] = Yes|No ; | trick.exec_set_thread_priority(<id>, 0|<n>) | PROCESS <id>'s SYSTEM SCHEDULING (NON-DEGRADING) PRIORITY |  |  |
sys.exec.in.rt_semaphores[<id>] = Yes|No ; | IMPLEMENTED but not settable, all children default to True | USE PTHREAD MUTEXES WHEN CHILDREN ARE IDLE |  |  |
sys.exec.in.rt_software_frame = 1.0e37|<sec> ; | trick.real_time_enable() OR trick.real_time_disable() trick.exec_set_software_frame(1.0|<sec>) | TURN REALTIME ON/OFF & SET REALTIME FRAME |  |  |
| trick.exec_set_thread_process_type(<id>, trick.PROCESS_TYPE_SCHEDULED| trick.PROCESS_TYPE_ASYNC_CHILD| trick.PROCESS_TYPE_AMF_CHILD) | SCHEDULING TYPE FOR CHILD THREAD <id> |  |  |
| trick.exec_set_thread_amf_cycle_time(<id>, <sec>) | RATE AT WHICH TO SYNC AMF CHILD(REN) THREAD WITH MAIN THREAD |  |  |
sys.exec.in.safestore_checkpoint = Yes|No ; | trick.checkpoint_safestore_set_enabled(True|False) | DUMP CHECKPOINT PERIODICALLY |  |  |
sys.exec.in.safestore_period = <sec> ; | trick.checkpoint_safestore(<sec>) | THE PERIOD TO DUMP SAFESTORE CHECKPOINT |  |  |
sys.exec.in.shutdown_wait_async = Yes|No ; | trick.exec_set_thread_async_wait(<id>, True|False) | WAIT FOR CHILD (TRICK7: ALL, TRICK10: <id>) BEFORE SHUTDOWN JOBS RUN |  |  |
sys.exec.in.sim_name = "<my_sim_name>" ; | message.mpublisher.sim_name = "<my_sim_name>" | USER PROVIDED SIMULATION NAME TO DISPLAY IN MSGS (DEFAULT IS BLANK) |  |  |
sys.exec.in.stack_trace = Yes|No ; | trick.exec_set_stack_trace(True|False) | PRINT DEBUGGER STACK TRACE IF SEG FAULT |  |  |
sys.exec.in.stripchart_input_file = "<mystrip_filename>" ; | trick_vs.stripchart.set_input_file("<mystrip_filename>") | LAUNCH STRIPCHART WITH FILE SPECIFYING STRIPCHART VARIABLES |  |  |
sys.exec.in.stripchart_sample_rate = 0.1|<sec> ; | NOT IMPLEMENTED | RATE AT WHICH STRIPCHART VARIABLES ARE SAMPLED |  |  |
sys.exec.in.time_tic = 0.000000001|<sec> ; | trick.exec_set_time_tic_value(1000000|<val>) | SIMULATION TIME RESOLUTION (TRICK10: 1/<val> IS A TIC) |  |  |
sys.exec.in.trap_sigbus = Yes|No ; | trick.exec_set_trap_sigbus(True|False) | ENABLE TRAP OF SIGBUS SIGNAL & GRACEFUL SHUTDOWN |  |  |
sys.exec.in.trap_sigfpe = Yes|No ; | trick.exec_set_trap_sigfpe(True|False) | ENABLE TRAP OF SIGFPE SIGNAL & GRACEFUL SHUTDOWN |  |  |
sys.exec.in.trap_sigsegv = Yes|No ; | trick.exec_set_trap_sigsegv(True|False) | ENABLE TRAP OF SIGSEGV SIGNAL & GRACEFUL SHUTDOWN |  |  |
sys.exec.in.tv = Yes|No ; | trick.trick_view_set_enabled(True|False) | START TRICK TV AUTOMATICALLY |  |  |
sys.exec.in.tv_input_file = "<mytv_filename>" ; | trick.trick_view_add_auto_load_file("<mytv_filename>") | AUXILIARY INPUT FILE SPECIFYING TV VARIABLES |  |  |
SYS EXEC WORK TRICK 7 | TRICK 10 | DESCRIPTION |  |  |
sys.exec.work.event_malf_broadcast = Yes|No ; | trick.set_event_info_msg_on() OR trick.set_event_info_msg_off() | SAVE WHEN EVENT/MALF TRIGGERED TO SEND_HS FILE IN RUN DIR (TRICK10: MESSAGES ARE PUBLISHED SO THEY ARE SENT TO THE SCREEN IN ADDITION TO THE SEND_HS FILE) |  |  |
sys.exec.work.cmdline_name | trick.command_line_args_get_cmdline_name() | COMMAND LINE EXECUTABLE COMMAND USED TO INVOKE SIM |  |  |
sys.exec.work.default_dir | trick.command_line_args_get_default_dir() | CURRENT SIMULATION DIRECTORY NAME |  |  |
sys.exec.work.freeze_command = Yes|No ; | trick.exec_set_freeze_command(True|False) | START SIM IN FREEZE MODE |  |  |
sys.exec.work.include_dir | N/A : use Python sys.path for includes | COMMAND LINE ARGUMENT (-I) INCLUDE PATH NAME (TRICK7 ONLY) |  |  |
sys.exec.work.input_file | trick.command_line_args_get_input_file() | COMMAND LINE ARGUMENT RUN INPUT FILE NAME |  |  |
sys.exec.work.mode | trick.exec_get_mode() | CURRENT SIMULATION COMMAND MODE |  |  |
sys.exec.work.output_dir | GET: trick.command_line_args_get_output_dir() SET: trick.set_output_dir("RUN_<rundir>|<mydir>") | COMMAND LINE ARGUMENT (-O) OUTPUT DIRECTORY NAME WHERE SIM OUTPUT IS STORED |  |  |
sys.exec.work.run_dir | trick_cmd_args.cmd_args.run_dir | COMMAND LINE ARGUMENT RUN DIRECTORY NAME |  |  |
sys.exec.work.save_send_hs_buffer = Yes|No ; | trick.message_file_subscribe() OR trick.message_file_unsubscribe() | SAVE HEALTH & STATUS (H&S) MSGS TO SEND_HS FILE IN RUN DIR |  |  |
sys.exec.work.save_var_server_msgs = Yes|No ; | trick.set_var_server_info_msg_on() OR trick.set_var_server_info_msg_off() | SAVE VARIABLE SERVER MESSAGES TO SEND_HS FILE IN RUN DIR (TRICK10: MESSAGES ARE PUBLISHED SO THEY ARE SENT TO THE SCREEN IN ADDITION TO THE SEND_HS FILE) |  |  |
sys.exec.work.send_hs_buffer_size = 1000000|<n> ; | NOT IMPLEMENTED | BUFFER SIZE FOR SAVING H&S |  |  |
sys.exec.work.send_hs_buffering = DR_Buffer|DR_No_Buffer|DR_Ring_Buffer ; | NOT IMPLEMENTED | BUFFER METHOD FOR SAVING H&S (SAME AS DATA RECORDING) |  |  |
sys.exec.work.terminate_time | trick.exec_get_terminate_time() | SIMULATION TERMINATION TIME |  |  |
sys.exec.work.var_serve_listen_dev.port = 7000|<n> ; | <my_int> = trick.var_server_get_port() trick.var_server_set_port(<my_int>) default is random port set by system | PORT ON WHICH CLIENTS CONNECT TO THE VARIABLE SERVER |  |  |
sys.exec.work.verify_input = Yes|No ; | Use the -d command line option: S_main_<hostcpu>.exe <run_input_file> -d | ECHO INPUT FILE AS IT IS PARSED WITHOUT EXECUTING SIM |  |  |
sys.exec.work.xtra_derivative = Yes|No ; | <simobj>.<myinteg>.set_last_step_deriv(True|False) | FORCE DERIVATIVE JOBS TO RUN AFTER LAST PASS OF INTEGRATION JOBS |  |  |
SYS EXEC MISCELLANEOUS TRICK 7 | TRICK 10 | DESCRIPTION |  |  |
sys.exec.ip.echo_input = Yes|No ; | NOT IMPLEMENTED | ECHO INPUT FILE AS IT IS PARSED |  |  |
sys.exec.ip.print_deprecated = Yes|No ; | NOT IMPLEMENTED | DISPLAY WARNING WHEN DEPRECATED VARIABLE USED |  |  |
sys.exec.out.time | trick.exec_get_sim_time() | CURRENT SIMULATION TIME |  |  |
sys.exec.sim_com.monitor_on = Yes|No ; | trick.sim_control_panel_set_enabled(True|False) | TURN SIM CONTROL PANEL ON |  |  |
SYS EXEC DATA RECORDING TRICK 7 | TRICK 10 | DESCRIPTION |  |  |
sys.exec.in.synchronous_dr_writer = Yes|No ; | NOT IMPLEMENTED; DR_Buffer groups are written asynchronously | MAKE THE DATA RECORDING WRITER FUNCTION SYNCHRONOUS |  |  |
sys.exec.in.user_dr_writer = Yes|No ; | N/A : derive your class from Trick's DataRecordBuffering class (see DataRecordThreaded) | CALL USER PROVIDED DATA RECORDING WRITER FUNCTION INSTEAD OF TRICK'S |  |  |
sys.exec.record.directory = "RUN_<rundir>|<mydir>" ; | trick.set_output_dir("RUN_<rundir>|<mydir>") | DIRECTORY WHERE RECORDING DATA FILES ARE SAVED |  |  |
sys.exec.record.group[<id>].ascii_label[<n>] = "<mylabel>" ; | NOT IMPLEMENTED | CHANGED VARIABLE'S DISPLAYED NAME (DR_ASCII) |  |  |
sys.exec.record.group[<id>].buffering = DR_Buffer|DR_No_Buffer|DR_Ring_Buffer ; | trick.add_data_record_group(<groupobj>, trick.DR_Buffer|trick.DR_No_Buffer|trick.DR_Ring_Buffer) | BUFFER METHOD FOR RECORDING DATA |  |  |
sys.exec.record.group[<id>].change_ref[<n>] = "<varname>" ; | <groupobj>.add_change_variable("<varname>") | TRICK VARIABLE NAMES TO TRIGGER RECORDING (DR_CHANGES) |  |  |
sys.exec.record.group[<id>].cycle = 1.0|<sec> ; | <groupobj>.set_cycle(0.1|<sec) | RATE AT WHICH DATA IS RECORDED FOR THIS GROUP |  |  |
sys.exec.record.group[<id>].freq = DR_Always|DR_Changes|DR_Changes_Step ; | <groupobj>.set_freq( trick.DR_Always|trick.DR_Changes|trick.DR_Changes_Step) | SPECIFY WHEN DATA IS RECORDED |  |  |
sys.exec.record.group[<id>].max_buffer_size = 1000000|<n> ; | <groupobj>.set_max_buffer_size(100000|<n>) | BUFFER SIZE FOR RECORDING GROUP DATA |  |  |
sys.exec.record.group[<id>].name = "<mygroupname>" ; sys.exec.record.group[<id>].format = DR_Binary|DR_Ascii|Dr_Fixed_Ascii ; | <groupobj> = trick.DRBinary("<mygroupname>") OR <groupobj> = trick.DRAscii("<mygroupname>") OR <groupobj> = trick.DRHDF5("<mygroupname>") | SPECIFY UNIQUE NAME FOR GROUP OUTPUT FILE SPECIFY RECORDING OUTPUT FORMAT |  |  |
sys.exec.record.group[<id>].record = Yes|No ; | <groupobj>.enable() OR <groupobj>.disable() | ENABLE RECORDING OF DATA |  |  |
sys.exec.record.group[<id>].ref[<n>] = "<varname>" ; | <groupobj>.add_variable("<varname>") | TRICK VARIABLE NAMES TO RECORD |  |  |
sys.exec.record.group[<id>].single_prec_only = Yes|No ; | <groupobj>.set_single_prec_only(True|False) | RECORD ALL DOUBLES AS FLOATS |  |  |
sys.exec.record.group[<id>].start = 0.0|<sec>; | NOT IMPLEMENTED; use enable/disable with read | SIM TIME TO START RECORDING |  |  |
sys.exec.record.group[<id>].struct_extract_bits = Yes|No ; | NOT IMPLEMENTED | EXTRACT BIT FIELDS WHEN RECORDING AN ENTIRE STRUCTURE |  |  |
sys.exec.record.group[<id>].user_alloc = Yes|No ; | NOT IMPLEMENTED this may work in Trick10 so not needed? | SET UP RECORDING AFTER INIT JOBS (FOR USER ALLOCED VARIABLE) |  |  |
sys.exec.record.num_groups = "16|<n>" ; | N/A : groups are instantiated as needed | NUMBER OF RECORDING GROUPS (16 ALLOCATED BY TRICK) |  |  |
sys.exec.record.terminate_on_bad_ref = Yes|No ; | NOT IMPLEMENTED | TERMINATE SIM WHEN RECORDING VARIABLE CANNOT BE FOUND |  |  |
| <groupobj>.set_job_class("data_record|<jobclass>") | JOB CLASS OF THE DATA RECORDING JOB FOR THIS GROUP |  |  |
SYS EXEC MASTER / SLAVE TRICK 7 | TRICK 10 | DESCRIPTION |  |  |
sys.exec.in.activate_slave[<n>] = Yes|No ; | <new_slave> = trick.SlaveInfo() master_slave.master.add_slave(<new_slave>) | ACTIVATE SLAVE # <n> (TRICK10: CREATE SLAVE OBJECT AND ACTIVATE) |  |  |
sys.exec.in.ms_sync = No_sync|Master_sync|Slave_sync ; | trick.ms_master_enable() OR trick.ms_master_disable() (sync types are N/A because the master / slave code is separate) | RUN MASTER SIM ONLY (DEFAULT), OR RUN & SYNC WITH SLAVES |  |  |
sys.exec.in.remote_shell = TRICK_SSH|TRICK_RSH|TRICK_USER_REMOTE_SH | <new_slave>.remote_shell = trick.TRICK_SSH|trick.TRICK_RSH| trick.TRICK_USER_REMOTE_SH | TYPE OF SHELL TO BRING UP SLAVE(S) WITH; THE COMMAND STRING = <remote_shell> <remote_shell_args> <machine_name> setenv DISPLAY <display_name>; cd <sim_path>; <S_main_name> <run_input_file> <connection args> -u <other_args> & |  |  |
sys.exec.in.remote_shell_args = "<args>" ; | <new_slave>.remote_shell_args = "<args>" | OPTIONAL ARGUMENTS TO USE WITH remote_shell CMD |  |  |
sys.exec.in.rt_sync_frame = 1.0e37|<sec> ; | NOT IMPLEMENTED; sync every frame (according to master) | MASTER/SLAVE SYNC FRAME |  |  |
sys.exec.in.slave_cnt = <num> ; | N/A do not set because slaves instantiated as needed, but can get : <my_int> = master_slave.master.num_slaves | NUMBER OF SLAVES DEFINED FOR A MASTER/SLAVE SIM |  |  |
sys.exec.in.slaves[<n>].machine_display = $DISPLAY|"<display>" ; | <new_slave>.machine_display = $DISPLAY|"<display>" | SLAVE'S X DISPLAY NAME |  |  |
sys.exec.in.slaves[<n>].machine_name = gethostname()|"<name>" ; | <new_slave>.machine_name = "localhost|<name>" | SLAVE'S REMOTE CONNECTION HOSTNAME |  |  |
<my_int> = sys.exec.in.slaves[<n>].overruns ; | NOT IMPLEMENTED | SLAVE'S NUMBER OF OVERRUNS THAT HAVE OCCURRED |  |  |
sys.exec.in.slaves[<n>].S_main_args[25] = "<rundir>/<inputfile> <args>" ; | <new_slave>.run_input_file = "<rundir>/<inputfile>" <new_slave>.other_args = "<args>" | SLAVE'S REMOTE EXECUTABLE RUN INPUT FILE AND CMD LINE -u ARGUMENTS |  |  |
sys.exec.in.slaves[<n>].S_main_name = "./S_main_${TRICK_HOST_CPU}.exe|<name>" ; | <new_slave>.S_main_name = "./S_main_${TRICK_HOST_CPU}.exe|<name>" | SLAVE'S REMOTE EXECUTABLE NAME |  |  |
sys.exec.in.slaves[<n>].sim_path = "<dir>" ; | <new_slave>.sim_path = "<dir>" | SLAVE'S REMOTE EXECUTABLE DIRECTORY PATH |  |  |
sys.exec.in.sync_error_terminate = Yes|No ; | <new_slave>.sync_error_terminate = False|True | MASTER/SLAVE SIM WILL TERMINATE ON SYNC ERROR |  |  |
sys.exec.in.sync_wait_limit = 1.0e37|<sec> ; | <new_slave>.sync_wait_limit = 0.0|<sec> | MAXIMUM TIME MASTER/SLAVE CONNECTION WILL WAIT FOR SYNC SIGNAL |  |  |
sys.exec.in.user_remote_shell = "<shell_cmd>" ; | <new_slave>.remote_shell = "<shell_cmd>" | USER DEFINED REMOTE SHELL CMD WHEN remote_shell IS TRICK_USER_REMOTE_SH |  |  |
SYS EXEC MONTE CARLO TRICK 7 | TRICK 10 | DESCRIPTION |  |  |
sys.exec.monte.in.activate = Yes|No ; | trick.mc_set_enabled(True|False) | ACTIVATE MONTE CARLO |  |  |
sys.exec.monte.in.dryrun = Yes|No ; | trick.mc_set_dry_run(True|False) | GENERATE monte_runs FILE CONTAINING RUNS THAT WOULD OCCUR WITHOUT ACTUALLY RUNNING |  |  |
sys.exec.monte.in.input_files[<n>] = "<monte_input_file>" ; | N/A monte input data set up using input file commands (see section 7.6) | AUXILIARY INPUT FILE(S) SPECIFYING MONTE INPUT DATA |  |  |
sys.exec.monte.in.localhost_as_remote = Yes|No ; | trick.mc_set_localhost_as_remote(True|False) | IF LOCALHOST SPECIFIED AS A SLAVE, USE REMOTE SHELL INSTEAD OF LOCAL SHELL |  |  |
sys.exec.monte.in.max_tries = 3|<n> ; | trick.mc_set_max_tries(2|<n>) | NUMBER OF TIMES TO TRY DISPATCHING SLAVE BEFORE GIVING UP |  |  |
sys.exec.monte.in.sequential_runs = Yes|No ; | N/A the Trick 10 implementation works implilcitly without this option | DISPATCH SLAVES SEQUENTIALLY (NEEDED WHEN OPTIMIZING WITH CALC VARIABLES) |  |  |
sys.exec.monte.in.slaves = alloc(<number of slaves>) ; | <new_slave> = trick.MonteSlave("<machine_name>") trick_sys.sched.add_slave(<new_slave>) | CREATE SLAVE(S) TO PERFORM RUNS |  |  |
sys.exec.monte.in.slaves[<n>].disable = Yes|No ; | trick_sys.sched.disable_slave("<machine_name>", True|False) | DO NOT USE THIS SLAVE |  |  |
sys.exec.monte.in.slaves[<n>].machine_name | <new_slave>.machine_name | SAME AS IN MASTER/SLAVE - SEE ABOVE |  |  |
sys.exec.monte.in.slaves[<n>].multiplier = 1|<n> ; | <new_slave>.multiplier = 1|<n> | CONSIDER SLAVE TO BE TIMED OUT multiplier TIMES FASTER THAN timeout VALUE |  |  |
sys.exec.monte.in.slaves[<n>].remote_shell | <new_slave>.remote_shell | SAME AS IN MASTER/SLAVE - SEE ABOVE; THE COMMAND STRING = <remote_shell> <remote_shell_args> <machine_name> <user_cmd_string>; cd <sim_path>; <S_main_name> <run_input_file> <misc monte args> -O & |  |  |
sys.exec.monte.in.slaves[<n>].remote_shell_args | <new_slave>.remote_shell_args | SAME AS IN MASTER/SLAVE - SEE ABOVE |  |  |
sys.exec.monte.in.slaves[<n>].S_main_name | <new_slave>.S_main_name | SAME AS IN MASTER/SLAVE - SEE ABOVE |  |  |
sys.exec.monte.in.slaves[<n>].sim_path | <new_slave>.sim_path | SAME AS IN MASTER/SLAVE - SEE ABOVE |  |  |
sys.exec.monte.in.slaves[<n>].user_remote_shell | <new_slave>.user_remote_shell | SAME AS IN MASTER/SLAVE - SEE ABOVE |  |  |
sys.exec.monte.in.timeout = 120.0|<sec> ; | trick.mc_set_timeout(120.0|<sec>) | TIME GIVEN TO DISPATCH & RECEIVE RESULTS FROM EACH SLAVE |  |  |
sys.exec.monte.in.user_cmd_string = "<args>" ; | trick.mc_set_user_cmd_string("<args>") | OPTIONAL ARGUMENTS APPENDED TO END OF remote_shell CMD |  |  |
| TRICK 10 SWIG NOTES |  |  |  |
| Certain advanced features of C++ such as nested classes are not yet supported. |  |  |  |
| Swig cannot provide access to C++ private/protected data. You can get around this if you need to assign private/protected data by using Trick's checkpoint reader: trick.read_checkpoint_from_string("<private_var> = <val>;") |  |  |  |