* (c)2000 T N Channon
* Crude script to assist with manual optimisation using Simulated Annealing.
* Expects two circuit blocks, ie. two outputs, one the signal you want and the 
* other the output from the circuit to be optimised.
* Hardcoded in here are the signal names x1out which is the one to be optimised
* and x2_out which is the reference. Place Terminals with these names on the 
* schematic or edit the names hereinunder.
* Set tolerance of components to optimise. Start with a huge tolerance, maybe 80%,
* then as completion approaches reduce the tolerance down to 5% or so but not in
* one step.
* Setup simetrix to do .ac over the range of frequencies you are interested in.
* Focus the schematic, press f11 and enter this line 
*           .keep /noi /nov x1out x2_out
* and press f11 again to close the window. This hugely reduces the disk space
* used and speeds things. It means we only keep the vectors of immediate interest.
* Run this script, then open file mclog.txt with and editor, find the entry with
* the reported best set of values, edit the schematic to these numbers or values
* you think are good. Close the edit mclog.txt window.
* What we are doing is interactive and needs thought.
* Be cautious about using a "best=" number which is larger than the last one, and
* usually it's much better to ignore the result and run the script again. If this
* fails many times, try reducing the tolerances, or possibly they are too tight.
* I can't teach SA here.

let range = 12 ;* TEST COMMENT
let value = 0
let answer = 0

anno
netlist design.net

** Script to run multiple simulations using component values
** read from a file
** First ask the user for a file
Let filename = GetSIMetrixFile('Text', ['open', 'all'])
if Length(filename)=0 then
    ** User cancelled box
    exit script
endif
** Read the file
Let lines = ReadFile(filename)
Let numLines = Length(lines)
** Test it has enough lines
if numLines<2 then
    Echo "Definition file must have at least two lines"
    exit script
endif
** We now parse the file and read in the component values
** to the array "compValues". We do the whole file at the
** beginning so that the user will know straight away if it
** has any errors.
** The first line is the list of components that will be changed
Let components=Parse(lines[0])
Let numComponents = Length(components)-1
if numComponents <= 1 then
    Echo "No component names specified or first line of config file empty"
    exit script
endif

** Before we read the rest of the file, we will attempt to
** replace the values of all listed components with parameters
** and netlist the circuit. If any of the components don't exist
** then we will find out here.
** array to store original values so that we can restore them later
Let origValues = MakeString(numComponents)
Unselect
Let error = 0
** Scan through list of components

if components[0] <> 'Components' then
    echo Keyword Components not found.
    exit script
endif 
for idx = 1 to numComponents
    ** Select it
    Select /prop ref {components[idx]}
    if SelectCount()=0 then
        ** Select count is zero so select failed.
        ** This means the circuit doesn't have this component
        ** Output a message and set error flag.
        Echo "Cannot find component " {components[idx]}
        Let error = 1
    else
        if HasProperty('value') then
            ** Save original value to be restored later
            Let origValues[idx-1] = PropValue('value')
            ** Set value as a parameter of name which is the same
            ** as the ref
            Let newVal = "'{' & PropValue('ref') & '}'"
            Prop value {newVal}
        else
            ** The component does not have a value property to alter.
            Echo "Component " {components[idx]} " does not have a value"
            Let error = 1
        endif
    endif
    Unselect
next idx
** We have changed all the components so now we can netlist the circuit
if NOT error then
    Netlist design.net
endif

** Once we have the netlist we can restore the original values
Unselect
for idx = 1 to numComponents
    Select /prop ref {components[idx]}
    if SelectCount()<>0 then
        if HasProperty('value') then
            Prop value {origValues[idx-1]}
        endif
    endif
    Unselect
next idx
** If we had an error we must now abort
if error then
    exit script
endif

** Now read the rest of the file.
** Create an array large enough to hold all the values.
** The values are actually stored as strings. That way we can vary
** model names as well as values.
Let compValues = MakeString(numComponents*(numLines-1))
Let error = 0
Let resIdx=0

let comps = MakeString(numcomponents)
let erange = MakeString(numcomponents)
let enableopti = vector(numcomponents)
let maxvalue = vector(numcomponents)
let minvalue = vector(numcomponents)

echo {numlines-1}
for lineIdx=1 to numLines-1
    ** Parse the line into individual values
    Let vals = Parse(lines[lineIdx])
   if Length(vals) > 0 then
         echo {lineIdx} {vals}

    if vals[0] == 'range' then
        for idx = 1 to numComponents
            let erange[idx-1] = vals[idx]
        next idx    
    elseif  vals[0] == 'enable' then
        for idx = 1 to numComponents
            let enableopti[idx-1] = Val(vals[idx])
        next idx    
    elseif  vals[0] == 'minimum' then
        for idx = 1 to numComponents
            let minvalue[idx-1] = Val(vals[idx])
        next idx    
    elseif  vals[0] == 'maximum' then
        for idx = 1 to numComponents
            let maxvalue[idx-1] = Val(vals[idx])
        next idx                            
    else
        echo Bad data source line.
        echo {vals}
*        exit script
    endif
    endif
next lineIdx
if error then
    exit script
endif


echo {components}
echo {minvalue}
echo {maxvalue}
echo {erange}


** For some strange reason it is necessary to do this again, 
** otherwise 'run' barfs. This may be an inconsistent problem.

let runparam = '.ac dec 10 50 20k'

netlist design.net
run /an {runparam} /file design.net

** resIdx finishes with the number of non-blank data lines
*Let numRuns = 50


let bestparam=''
let tot2 = 0
let sumdiff = 0
let shake = Vector(numComponents)
let maybe = shake
let bestfound = origvalues
*debug echo {numcomponents} {length(bestfound)}{bestfound}
let iteration = 0
let holdoff = 11
let best = -1e6
let got_reference = false
let heat = 0.8
let HOLD = floor(sqrt(numComponents) * 7)
echo {hold}
let COOL = 0.75
let ereplaceidx = numComponents-1
let ereplace = Vector(numComponents)
let evaluateonly = 0
let useEvalues = 0
 
*    plot /xlog  db(:x1out)-db(:x2_out)
*    let best = RootSumOfSquares(db(:x1out)-db(:x2_out))
echo Err={1-best} Heat={heat} 
  
** Now, at last, we can run the circuit

do while 1
    do while heat>0.02
        if (got_reference = true) AND (evaluateonly == 0) then

            let iteration = iteration + 1
            for idx2=0 to numComponents-1
              let shake[idx2] = heat
              let maybe[idx2] = 1
            next idx2
            let shake = rnd(shake)
            let maybe = rnd(maybe)
            for idx2=0 to numComponents-1
                if (enableopti[idx2] == 1) AND (maybe[idx2] > 0.3s) then
                    let shake[idx2] = shake[idx2] + 1 - (heat/2)
*debug                    echo {components}
                    Select /prop ref {components[idx2+1]}
*debug                    echo {bestfound[idx2]}
                    let newval = {bestfound[idx2]} * shake[idx2]

                    if newval < minvalue[idx2] then
                        let newval = minvalue[idx2]
                    elseif newval > maxvalue[idx2] then
                        let newval = maxvalue[idx2]
                    endif
                    
* use e range   
                    if useEvalues == 1 then
                        GetStandardValue erange[idx2] newval @answer
                        let newval = answer
                        if newval < minvalue[idx2] then
                            let newval = minvalue[idx2]
                        elseif newval > maxvalue[idx2] then
                            let newval = maxvalue[idx2]
                        endif                    
                    endif
                   
                    prop value {newval}
                    Unselect
                endif
            next idx2
        endif
    
   
        netlist design.net    
        Run /an {runparam} /file design.net


            let diff = db(:x1out)-db(x2_out)
            let sumxy = 0; let sumx2 = 0; let sumy2 = 0; 
            let N = length(:x1out)
            let avx =0; let avy = 0
            for idx2=0 to N-1
               let avx = avx + db(:x1out[idx2])
               let avy = avy + db(x2_out[idx2])
            next idx2 
            let avx = avx / N; let avy = avy / N   
            for idx1=0 to N-1
                let sumxy = sumxy + ((db(:x1out[idx1])-avx) * (db(:x2_out[idx1])-avy))
                let sumx2 = sumx2 + ((db(:x1out[idx1])-avx) * (db(:x1out[idx1])-avx))
                let sumy2 = sumy2 + ((db(x2_out[idx1])-avy) * (db(x2_out[idx1])-avy))        
            next idx1

            let sdx = sqrt(sumx2/N)
            let sdy = sqrt(sumy2/N)

            let best1 = RootSumOfSquares(db(:x1out)-db(:x2_out))

            let tot2 = mag((sumxy/N) / (sdx * sdy))
            let tot2 = tot2 - (best1 / 10000)

    * debug       echo {mag(sumx2)} {mag(avx)} {mag(avy)} {tot2}
 
    * debug       echo {best1} {tot2} {best}       
    
*   Test for best so far, if so save and pump up hold off from cooling just yet.
    
            if (tot2 > best) OR (evaluateonly == 1) then
                let evaluateonly = 0
                let holdoff = HOLD
                let best=tot2;
                
*** Save best values into schematic

                for idx3=0 to numComponents-1
                    Select /prop  ref {components[idx3+1]}
                    let bestfound[idx3] = propvalue('value')
                    Unselect
                next idx3

* Give the punter a progress list item.

                echo Err={1-best} Heat={heat}
                
*   Remove the last curve if there are two so we can add a new one 

                let curv = GetAllCurves()
                if length(curv) >= 2 then
                    let hcurv = sort(curv)            
                    DelCrv {curv[0]}
                endif
                
                
*   Now add a graph curve                

                if got_reference = true then    ;* Normal path here, add curve 
                    curve /yunit dB /xlog diff
                else
                    let got_reference = true    ;* Initialisation, open graph and plot
                    plot /xlog /yunit dB diff   ;* This is the static reference curve
*                    NewAxis                    ;* Uncomment if you want dual axis
                endif
            else
                for idx3=0 to numComponents-1
                    Select /prop ref {components[idx3+1]}
                    prop value {bestfound[idx3]}
                    Unselect
                next idx3  
                if holdoff > 0 then
                    let holdoff = holdoff - 1
                else
                    let heat = heat * COOL
                    let holdoff = HOLD
                    echo Err={1-best} Heat={heat}
                endif 
            endif
    loop

for idx=0 to numComponents-1
   echo {components[idx+1]} = {bestfound[idx]}
next idx

exit script
    
*   Find next E range value to replace, ignoring components not being optimised
    do while 1  ;* script needs defined evaluation and termination order, do exit manually
        if (ereplaceidx < 0) then   ; * Got to the end of array, exit
            exit while
        endif
        if (enableopti[ereplaceidx] <> 0) then  ;* Exit if this component is optim enabled
            exit while
        endif
        let ereplaceidx = ereplaceidx - 1       ;* Decrement index down array.
    loop

    if ereplaceidx < 0 then     ;* Everything done, exit to script end code.
        exit while
    else
        let idx2 = ereplace[ereplaceidx]
        Select /prop ref {components[idx2+1]}
        Select /prop Val(PropValue('value'))
*debug        echo After select prop {newval}
        GetStandardValue erange[idx2] newval @answer
        let newval = answer
        if newval < minvalue[idx2] then
          let newval = minvalue[idx2]
        elseif newval > maxvalue[idx2] then
            let newval = maxvalue[idx2]
        endif
*debug        echo After get E {newval}

        let vv = str(newval)
        let bestfound[idx2] = vv
        prop value {vv}
*debug        echo After restore schematic {vv}
        Unselect        
        let ereplaceidx = ereplaceidx - 1    
        let enableopti[idx2] = 0
        let heat = 0.1
        let evaluateonly = 1
    endif
loop

for idx=0 to numComponents-1
   echo {components[idx+1]} = {bestfound[idx]}
next idx