AnsweredAssumed Answered

Oscillator Sensitivity/Yield Analysis?

Question asked by GWHITE on Oct 12, 2004
Latest reply on Oct 15, 2004 by mfredrik

Like • Show 0 Likes0
Comment • 6

I have an oscillator design, and I would like to make sure that it will oscillate over a range of component values. Because "oscillation" is a binary sort of issue (it does or it doesn't), normal sensitivity analysis won't work. I can do yield analysis, but it just tells me what my yield is. I haven't figured out a way to interpret/plot the results to tell me what component values caused it to fail. I can play around with tuning each component manually, but I don't want to have to go through that exercise each time I make a change.

The yield system should have the info I need, but I don't understand how to get at it. For example, let's say I have an L & a C that I want to work with. What I'd like to get is a plot of what range of values for each gives me 100% yield. To make life more complicated, the results will not be independent. I could do a surface plot, but I get stuck if I add another variable. Because it's a Monte Carlo analysis, one option would be a list of all of the parameter combinations that worked. It would be a pain to wade through but at least I could see what was going on. There are a variety of yield variables, but I haven't found the section in the manual that explains exactly what they are. Experimental plots haven't given any results that make sense to me. They do warn you that if you ask for all of the simulation data, that it will be huge & slow the simulation down. No where do they explain exactly what info would be contained in such a data set, or how to get at the bits I need.

I tried yield optimization, but that only comes up with a single value that it is happiest with, not a range, nor does it provide info on any interactions.

Any suggestions would be appreciated. Is there an example someplace that deals with this?

Thanks!

No one else has this question

Outcomes

6 Replies

mfredrik Oct 13, 2004 3:11 AM
Mark Correct
Correct Answer
You don't need all simulation data in the dataset, but you do need to make sure you output the Random Variables in order to be able to plot the performance vs component values etc.

On the Yield/Monte Carlo-Controller, go to the Parameters tab and make sure "Random Variables" is checked.

In the dataset you will now find the component values that varies for each iteration (mcTrial).

How to make sense of all this data is a bit of a challenge as you've already figured out. One way is to look at the sensitivity of each component vs some criteria, for instance Yield.

There is one example which ships with ADS that you can look at:

/examples/Tutorial/Statistical_Design_prj

(You can download the ADS 2003C version of this example here in case you don't have the examples installed)

If you open this example and look at the data display called sens_hist_all_parts.dds. This datadisplay plots the sensitivity for all parts vs the total Yield. What you can tell from this kind of plots is if there is any component(s) that is extra sensitive. In this case you can see that Lres1 is very sensitive and has to be kept under control, i.e. buy extra tight tolerance on this part or use tuning.

What these type plots still don't show you is which combinations of component values are good/bad. For two components you could do a surface plot, but with many components then it's more complicated.

The sensitivity plots vs component values are the only thing I can think of right now. Someone else might have an idea!?

To adapt the sensitivity plot to you case, i.e. Osc/No Osc, you could do something like this:

I did some experiments with this Oscilator example and found that the Oscillation frequency was 0 Hz for the iterations which failed to oscillate.

This equation indicates all iterations which failed to oscilliate:

MyOsc = if (OscFrequency == 0) then 1 else 0

You can the relate this to a component, for instance C1:

Osc_vs_C1 = vs(MyOsc,C1)

Finally, you can create a histogram like this:

Osc_Sens_vs_C1 = yield_sens(Osc_vs_C1,21)

where 21 is the number of binaries in the histogram

If you plot Osc_Sens_vsC1 you will get a histogram which indicates which component values of C1 caused a oscillation failure. You will have to write these three equations for each component. You can then see which range of values, for each component, causes problems.

I hope this is of some help..
Like • Show 0 Likes0
Actions
GWHITE Oct 13, 2004 4:24 AM
Mark Correct
Correct Answer
Thanks! That certainly gives me some things to play with.

One problem I'm having is that my yield seems to be dominated by simulation convergence issues. The "OscPort" isn't reporting that it can't find a valid oscillation condition (although I've seen that on occasion). Instead, I'm running into a variety of convergence failures. Some are warnings, and some are errors. I don't know if the warnings are counted as a failure. The errors are things like:

Oscillator analysis did not converge. Setting solution to zero.

or:

Cannot sweep to desired level.

Depending on how I have my simulation parameters set up, I can get yields from 99.8% to 95% with the same component settings. This is for 1000 trials. Until I can fix that issue, worrying about my components is a bit futile. Of course, it's the component variatiosn that are confusing the sims, so it's all interrelated.
Like • Show 0 Likes0
Actions
GWHITE Oct 14, 2004 8:58 AM
Mark Correct
Correct Answer
mfredrik,

I followed some of your suggestions, and I now have plots that show which values of each component passed or failed the oscillation test. What I'm seeing are apparently random failures, rather than ranges of component values that don't work. This makes me suspect that the limiting factor in my yield is still simulation convergnece, and not my oscillator design.

In an attempt to pin this down further, I'd like to create a list display of the component values that were used for each failed analysis. I can get the index of the failures by using the find function, but I haven't been able to come up with a function or syntax that would allow me to extract the appropriate values from the component arrays. For example, I have:

Eqn Bad_Index=find(Osc_OK==0)

This gives me an array of (for this 500 point test run) 6 indeces: 137, 182, 212, 278, 304, 417.

I have a 500 element array of capacitor values, HB1.Cbase, but I can't find a way to use "Bad_Index" to add just those values to a list.

I'm assuming there is a simple syntax or function that will do this, but I haven't been able to figure it out.

Any suggestions?

Thanks!
Like • Show 0 Likes0
Actions
mfredrik Oct 14, 2004 12:11 PM
Mark Correct
Correct Answer
I wish I could think of any simple syntax to accomplish this ???

I'm almost sure there is a way to write some equations to do this, but I can't think of any right now.

Anyway, this is easily solved with a custom AEL Expression. Here's some code that should do the trick:

defun get_data_points(data,indeces)
{

// Copy input arrays to local vars for speed
decl local_data = data;
decl local_indeces = indeces;

decl NrPoints=sweep_size(local_indeces);
decl i;

// Create the array
decl X = create(1, "Real", {"index"}, {"Real"},1, 1);
// Get the Independent variable (index)
decl indep_X = indep(X,"index");

// Populate the new array
for(i=0; i<NrPoints; i++)
{
indep_X[i] = local_indeces[i]; // Set the index value
X[i] = local_data[i]; // Set the data value
}
return X;
}
- Save the code above into a text file called get_data_points.ael.
- Follow this instruction to install the custom function into the ADS expression handler.
- Once you've got the function installed you can use this syntax to get all Cbase values for the non-osc cases:
  
  Bad_Index=find(Osc_OK==0)
  Bad_Cbase=get_data_points(HB1.Cbase,Bad_Index)
Like • Show 0 Likes0
Actions
GWHITE Oct 15, 2004 1:51 AM
Mark Correct
Correct Answer
Thanks! I'm glad I didn't miss something obvious.

I implemented the ael routine, and at first glance, it sort of appears to work, but there was something fishy going on. It give me an array of component values, but they didn't match the points that fail.

I did some further poking, and instead of using the bad index points to extract the component values, it's just giving me the first N points of the component array, where N is the total number of bad points. I examined the code, and although this is the first time I've examined raw ael stuff, I think I found a problem in the line:

X[i] = local_data[i]; // Set the data value

I changed it to:

X[i] = local_data[indep_X[i]]; // Set the data value

This seems to pick out the right values now.

Now all I have to do is interpret the results. The values that fail appear to be quite random, which makes me suspect the analysis convergence problem more than the oscillator. I ran a bunch of experiments with various simulation setings, and I can't seem to do better than between 95% to 99% yield. The status display will occasionally complain that the circuit isn't meeting the OscPort stability criteria, but most of the time, it's complaining about convergence issues.

What I had hoped to see from the analysis was that (for example), values of Cbase below 10 pF cause the circuit to fail consistently. Instead, I see an increase in the number of failures below 10 pF, but most trials still work fine. Without some further digging, it's hard to tell if the circuit isn't working down there, or the HB analysis isn't converging. It is also likely that there are interactions with the other component values, i.e. it only fails to oscillate with Cbase below 10 pF if Rbase is greater than 8K or something.

At least now I have some better tools to investigate the circuit with.

Thanks again for the help.
Like • Show 0 Likes0
Actions
mfredrik Oct 15, 2004 2:45 AM
Mark Correct
Correct Answer
Ooops, sorry for the mistake :-/

Glad you were able to find the problem and correct it!

Here's the corrected/working code, in case someone else needs it:

defun get_data_points(data,indeces)
{

// Copy input arrays to local vars for speed
decl local_data = data;
decl local_indeces = indeces;

decl NrPoints=sweep_size(local_indeces);
decl i;

// Create the array
decl X = create(1, "Real", {"index"}, {"Real"},1, 1);
// Get the Independent variable (index)
decl indep_X = indep(X,"index");

// Populate the new array
for(i=0; i<NrPoints; i++)
{
indep_X[i] = local_indeces[i]; // Set the index value
X[i] = local_data[indep_X[i]]; // Set the data value
}
return X;
}

As you said, it should be much easier to analyze the results now.

If you need further help on determening why the simulation fails to converge in these cases, please contact Technical Support.
Like • Show 0 Likes0
Actions

Oscillator Sensitivity/Yield Analysis?

Outcomes

Related Content

Recommended Content