order of output evaluation in maestro results pane

Hi Sergei,

ADE figures out the dependencies between output expressions and ensures they are evaluated in order based on that dependency. So you could just make your my_metric expression:

run_python && read_file("my_file.txt" 1)

I think that should work. run_python will be true (0 is true in SKILL) and the overall result of the expression will be the read_file result. 

Andrew

Dear Andrew

I am genuinely surprised how promptly you have responded.

this is a good idea, I will try it.

The complication is that in my real setup I read the same file three times (read the first line of the file to the output py_gain -> read the second line of the file to the output py_offset -> read the third line of the file to the output py_rms_error):

pic 1 (this is the real setup)

the contents of py_data.txt are

$ cat py_data.txt
0.8626197392827424
0.0003209694507691382
0.0008287802591069362

So, if I use the solution proposed by you, I need to execute the same python script three times (while currently this is accomplished by running the script once).

Can this be circumvented somehow (so that the python script is executed only once)?

Hi Sergei,

The solution I proposed doesn't require the python script to be executed three times. Each of py_gain, py_offset and py_rms_error would use the result of run_python (which would be 0) to compute the result - but it would only be evaluated once. There's then a dependency between the expressions so that ADE knows that run_python must be evaluated first because the other three expressions are dependent upon it.

Andrew

Dear Andrew

You are right, your solution doesn’t seem to require multiple executions of run_python.

The solution you proposed solves my problem. Thank you very much. You are my savior.

The final solution which I picked (for possible reference by the community):

The arrows on the pic above show that an output name is used as an input in the next chain member.

where

procedure(
 return_true(any_arg)
  t
)

Several comments

1) run_python occasiaonally returned values other than zero. So, return_true function was introduced.

alternatively instead of “return_true(run_python)”, “ run_python != 256” could have been used as Linux exit codes are between 0 and 255 as I know.

2) my real code was more complicated that described above. There were more steps, in particular, there was an operation where a waveform was saved to the disk. Occasionally it was executed after run_python which produced an error.

So, finally this way a desired chain of executions was achieved.

3) I’m not sure that “0” and “t” can be used interchangeably in SKILL (you said “0 is true in SKILL”).

In both of the statements ‘0 && (b=3)’ and ‘1 && (b=3)’, the second command is executed (3 is assigned to b).

So, it seems using ‘t’ and ‘nil’ is a more reliable way to control wheter the second statement is executed or not (rather than 0 and not 0).

Dear Andrew

You are right, your solution doesn’t seem to require multiple executions of run_python.

The solution you proposed solves my problem. Thank you very much. You are my savior.

The final solution which I picked (for possible reference by the community):

The arrows on the pic above show that an output name is used as an input in the next chain member.

where

procedure(
 return_true(any_arg)
  t
)

Several comments

1) run_python occasiaonally returned values other than zero. So, return_true function was introduced.

alternatively instead of “return_true(run_python)”, “ run_python != 256” could have been used as Linux exit codes are between 0 and 255 as I know.

2) my real code was more complicated that described above. There were more steps, in particular, there was an operation where a waveform was saved to the disk. Occasionally it was executed after run_python which produced an error.

So, finally this way a desired chain of executions was achieved.

3) I’m not sure that “0” and “t” can be used interchangeably in SKILL (you said “0 is true in SKILL”).

In both of the statements ‘0 && (b=3)’ and ‘1 && (b=3)’, the second command is executed (3 is assigned to b).

So, it seems using ‘t’ and ‘nil’ is a more reliable way to control wheter the second statement is executed or not (rather than 0 and not 0).

In SKILL, nil means false, and anything else means true (so t, "hello", 1, 0, 256 are all true). So not really sure that you really need your return_true() function - unless there is some reason for the dependent result to return nil and still be treated as "success"?

Andrew

I agree, probably instead of

return_true(previous_chain_element) && do_something()

just

previous_chain_element && do_something()

can be used and it should work.

At that, if previous_chain_element by coincidence is evaluated to nil, do_something() will not be executed, what is not expected behavior.

So, using return_true ensures that both

1) the second command (after &&) is always executed

and

2) the proper order of command execution is communicated to ADE.

sergeiGorbikov said:

At that, if previous_chain_element by coincidence is evaluated to nil, do_something() will not be executed, what is not expected behavior.

That said, I would expect that if your previous output returned nil, that might reasonably indicate an error condition, and so it probably doesn't make a great deal of sense for the subsequent expression to be evaluated. Of course, this rather depends on previous_chain_element returning something useful (which I just assumed it would, and wouldn't just return some random value which might accidentally be nil). Anyway, this all depends on your setup - your mileage may vary!

Andrew