Ocean script query

 Hi Pramod,

There is a SourceLink solution that I believe can you help you with this: Solution 11508500

The short answer is to use errset() around any code that is throwing an error to programmatically trap and handle the error condition.

Regards,

Lawrence.

I disagree with Lawrence a little on this. I think that actually the right way to handle this is using the first approach in that solution (I think the approaches in the solution came from something I said in an internal discussion anyway). That is to do this kind of thing:

when(member('ac results())
  PM=phaseMargin(VF("/out"))
  when(PM
    fprintf(fp "Phase margin = %f\n" PM)
  )
)

In other words, it's better to explicitly check for various things - in this case, we check that the ac results are present (maybe it failed for some reason) prior to trying to calculate the phaseMargin. In other words, at each stage, check the result of an expression was non-nil before using it in another expression or print.

Using errset() is fine when you have no control over the code being executed - but using it to trap errors is a slightly lazy approach and doesn't allow much precision in pinpointing where the error occurred (not strictly true, but true if you just stick errset around a massive piece of code). Far better to code defensively, checking for unexpected results at each point, and handling the problem as soon as it occurs.

Best Regards,

Andrew.

One possibility is to check that the last X point is where you think it is. You could use the abLastX function from below on a waveform:

/* abFirstLast.il

Author     A.D.Beckett
Group      Custom IC (UK), Cadence Design Systems Ltd.
Language   SKILL
Date       Mar 02, 2009 
Modified   
By         

Functions for finding the first and last X and Y points
in a waveform. To register abFirstX, abFirstY, abLastX, abLastY
with the calculator (so they show up in the user defined special
functions), call

abRegFirstLastCalcFunctions()

***************************************************

SCCS Info: @(#) abFirstLast.il 03/02/09.06:53:01 1.1

*/

/***************************************************************
*                                                              *
*                       (abFirstY wave)                        *
*                                                              *
*          Return the first Y value from the waveform          *
*                                                              *
***************************************************************/
(defun abFirstY (wave)
  (cond
    ((drIsWaveform wave)
     (drGetElem (drGetWaveformYVec wave) 0)
     )
    ((famIsFamily wave)
     (famMap 'abFirstY wave))
    (t
      (artError "abFirstY: can't handle %L\n" wave)
      )
    )
  ) ; defun abFirstY

/***************************************************************
*                                                              *
*                       (abFirstX wave)                        *
*                                                              *
*          Return the first X value from the waveform          *
*                                                              *
***************************************************************/
(defun abFirstX (wave)
  (cond
    ((drIsWaveform wave)
     (drGetElem (drGetWaveformXVec wave) 0)
     )
    ((famIsFamily wave)
     (famMap 'abFirstX wave))
    (t
      (artError "abFirstX: can't handle %L\n" wave)
      )
    )
  ) ; defun abFirstX

/***************************************************************
*                                                              *
*                        (abLastY wave)                        *
*                                                              *
*          Return the last Y value from the waveform           *
*                                                              *
***************************************************************/
(defun abLastY (wave)
  (cond
    ((drIsWaveform wave)
     (let (len vec)
       (setq vec (drGetWaveformYVec wave))
       (setq len (drVectorLength vec))
       (drGetElem vec (sub1 len))
       )
     )
    ((famIsFamily wave)
     (famMap 'abLastY wave))
    (t
      (artError "abLastY: can't handle %L\n" wave)
      )
    )
  ) ; defun abLastY

/***************************************************************
*                                                              *
*                        (abLastX wave)                        *
*                                                              *
*          Return the last X value from the waveform           *
*                                                              *
***************************************************************/
(defun abLastX (wave)
  (cond
    ((drIsWaveform wave)
     (let (len vec)
       (setq vec (drGetWaveformXVec wave))
       (setq len (drVectorLength vec))
       (drGetElem vec (sub1 len))
       )
     )
    ((famIsFamily wave)
     (famMap 'abLastY wave))
    (t
      (artError "abLastX: can't handle %L\n" wave)
      )
    )
  ) ; defun abLastX

/***************************************************************
*                                                              *
*                 (abFirstLastGenCB funcName)                  *
*                                                              *
*   Macro (and invocations) to build the calculator callback   *
*                          functions.                          *
*                                                              *
***************************************************************/
(defmacro abFirstLastGenCB (funcName)
  `(defun ,(concat funcName 'CB) ()
     (calSpecialFunctionInput (quote ,funcName) nil)
     ))
(abFirstLastGenCB abFirstX)
(abFirstLastGenCB abFirstY)
(abFirstLastGenCB abLastX)
(abFirstLastGenCB abLastY)

/***************************************************************
*                                                              *
*                (abRegFirstLastCalcFunctions)                 *
*                                                              *
* Register all four first/last functions as special functions  *
*                     for the calculator.                      *
*                                                              *
***************************************************************/
(defun abRegFirstLastCalcFunctions ()
  (foreach func '(abFirstX abFirstY abLastX abLastY)
           (calRegisterSpecialFunction
             (list (get_string func) (concat func 'CB)))
           )
  ) ; defun abRegFirstLastCalcFunctions

 Thanks, I think I came up with something similar

 last_step=ymax(xval(VT("/out")))

if(last_step>2u converged=1 converged=0)

If there are a lot of points, then abLastX will be more efficient than the ymax approach, but other than that you probably won't notice the difference.

Regards,

Andrew.