WL6 hangs when clicking into Strategy Parameters Sliders

Ben_Zurich

#1

9/6/2012 9:27 AM

I don't know how and when this condition first occured but I can no longer click into the Strategy Parameters sliders without causing WL6 to hang.

Double clicking on a Strategy Parameter and typing in another value works well, however.

Optimizing works too.

I am using Visual C# and there are no breakpoints set.

What could cause this condition ?

Eugene

#2

9/6/2012 9:53 AM

Show us the Strategy code, and we'll try to determine what went wrong.

Ben_Zurich

#3

9/6/2012 10:55 AM

CODE:
Please log in to see this code.

Size:

Color:

[CODE]using System;
using System.IO;
using System.Xml.Serialization;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using WealthLab;
using WealthLab.Indicators;
using WealthLab.DataProviders.Blmbrg;
using Strategies.Compass;

namespace Strategies.Compass
{

//-----------------------------------------------------------------------
    // STEP STRATEGY CLASS OBJECTS
    //-----------------------------------------------------------------------

public class StepStrategy : WealthScript
    {
        // data file
        static int STEPS = 2;
        
        // Display Parameters
        static int stepPaneHeight = 40;
        //static int combPaneHeight = 80;
        static int subPaneHeight = 80;
        static Color firstIndColor = Color.Red;
        static Color secondIndColor = Color.Green;

// ZigZag Parameters: show high/lows of main data as vertical lines
        static bool zigzag = false;
        static double troughPerc = 7.5;
        static double peakPerc = 7.5;
        static Color peakColor = Color.Red;
        static Color troughColor = Color.Green;
        static LineStyle lineStyle = LineStyle.Dotted;
        static int lineWidth = 2;
        static double minVertLine = -10000;
        static double maxVertLine = 10000;

static int maxNoOfSubPanes = 20;
        static int maxNoOfParams = 10;

// Optimizing Parameters (Initialization)
        StrategyParameter[] weight = new StrategyParameter[maxNoOfSubPanes];
        StrategyParameter[] optParm = new StrategyParameter[maxNoOfParams];

Market market;
        MarketGroup group;
        MarketGroupComponent component;
        MarketGroupComponentModule module;
        MarketGroupComponentModuleInput input;
        MarketGroupComponentModuleOutput output;
        MarketGroupComponentModuleParameter parameter;
        int parmCount;
        int activeCount;

//-----------------------------------------------------------------------
        // STEP STRATEGY METHOD (CALLED WHEN WORKSPACE LOADED)
        //-----------------------------------------------------------------------
        
        public StepStrategy()
        {
            string xmlFile = "";
            try
            {

//-----------------------------------------------------------------------
                // UNMARSHALL XML FILE
                //-----------------------------------------------------------------------

String path = Environment.GetFolderPath(Environment.SpecialFolder.Personal) +
                              "\\Visual Studio 2010\\Projects" +
                              "\\WealthLab.Strategies.Compass\\WealthLab.Strategies.Compass\\";
                string xmlFileContainer = path + "WL6XML.txt";
                if (File.Exists(xmlFileContainer))
                {
                    StreamReader myFile = new StreamReader(xmlFileContainer, System.Text.Encoding.Default);
                    xmlFile = myFile.ReadLine();
                    myFile.Close();
                }
                else
                {
                   Console.Error.Write(xmlFileContainer + " not found in " + path);
                   Environment.Exit(0);
                }
                if (!File.Exists(path + xmlFile))
                {
                    Console.Error.Write(xmlFile + " not found in " + path);
                    Environment.Exit(0);
                }
                StreamReader reader = new StreamReader(path + xmlFile);
                XmlSerializer serializer = new XmlSerializer(typeof(Market));
                market = (Market)serializer.Deserialize(reader);
                reader.Close();
            }
            catch (Exception e)
            {
                Console.Error.Write("Invalid File " + xmlFile);
                Console.Error.Write(e);
                Environment.Exit(0);
            }

//-----------------------------------------------------------------------
            // DETERMINE SINGLE MODE
            //-----------------------------------------------------------------------

parmCount = 0;
 activeCount = 0;
 int lastActiveGroup = -1;
 int lastActiveComponent = -1;
 // determine if single or step run
 for (int g = 0; g < market.Group.Length; g++)
 {
 group = market.Group[g];
 for (int c = 0; c < group.Component.Length; c++)
 {
 if (group.Component[c].Single)
 {
 activeCount++;
 lastActiveGroup = g;
 lastActiveComponent = c;
 }
 } // component
 } // group
 component = market.Group[lastActiveGroup].Component[lastActiveComponent];

//-----------------------------------------------------------------------
 // PARAMETERS
 //-----------------------------------------------------------------------
 
 for (int m = 0; m < component.Module.Length; m++)
 {
 module = component.Module[m];
 // push parameters from XML to WL6
 // optimization of single component
 if (module.Parameter != null)
 {
 for (int p = 0; p < module.Parameter.Length; p++)
 {
 parameter = module.Parameter[p];
 if (parameter.Opt) // && module.ToString() != "Trade")
 {
 optParm[parmCount++] = CreateParameter(parameter.Name.ToString(),
 parameter.Choice, parameter.Low, parameter.High, parameter.Step);
 }
 } // parameter
 } // has parameter
 } // methods
 } // StepStrategy

//-----------------------------------------------------------------------
        // EXECUTE METHOD (CALLED FOR EVERY ITERATION)
        //-----------------------------------------------------------------------
        
        protected override void Execute()
        {
            Bars[] bars = new Bars[100];
            DataSeries[] series = new DataSeries[100];
            DataSeries stepSeries = new DataSeries(Bars, "Step");
            DataSeries sumSeries = new DataSeries(Bars, "Sum");
            ChartPane[] pane = new ChartPane[100];
            ChartPane stepPane = new ChartPane();
            string[] barsName = new string[100];
            string[] outputName = new string[100];
            int barsObjectCount = 0, paneCount = 0;
            Color[] color = { Color.Blue, Color.Red, Color.Green, Color.Black, Color.Magenta, Color.Brown };
            //Obtain Optimizing Parameters Values
            try
            {
                HideVolume();
                string previousPane = "";

//-----------------------------------------------------------------------
                // GROUP LOOP
                //-----------------------------------------------------------------------

for (int g = 0; g < market.Group.Length; g++)
 {
 group = market.Group[g];

//-----------------------------------------------------------------------
                    // COMPONENT LOOP
                    //-----------------------------------------------------------------------

string[] compName = new string[group.Component.Length];
 for (int c = 0; c < group.Component.Length; c++)
 {
 component = group.Component[c];
 if (!component.Single) continue;
 compName[c] = component.Name;
 int pCount = 0;

//-----------------------------------------------------------------------
                        // MODULE LOOP
                        //-----------------------------------------------------------------------

for (int m = 0; m < component.Module.Length; m++)
 {
 module = component.Module[m];
 int[] parm = null;
 if (module.Name.ToString() == "Trade" && activeCount > 1) continue;
 if (module.Parameter != null)
 {

//-----------------------------------------------------------------------
                                // PARAMETER LOOP
                                //-----------------------------------------------------------------------

parm = new int[module.Parameter.Length];
 for (int p = 0; p < module.Parameter.Length; p++)
 {
 parameter = module.Parameter[p];
 // single strategy: take optimizing parms
 if (activeCount == 1 && parameter.Opt)
 {
 parm[p] = optParm[pCount].ValueInt;
 pCount++;
 }
 // step strategy or single strategy without opt
 // take the already optimized parms
 else
 parm[p] = parameter.Choice;
 } // parameter
 } // has parameters

// initialize inputBarsIndex for every module
                            int[] inputBarsIndex = new int[module.Input.Length];
                            // search for input series of that module

//-----------------------------------------------------------------------
                            // INPUT LOOP (LOOK FOR EXISTING BARS / SERIES)
                            //-----------------------------------------------------------------------

for (int i = 0; i < module.Input.Length; i++)
 {
 // is input series already existing ?
 bool found = false;
 inputBarsIndex[i] = -1;
 input = module.Input[i];
 // don't search if bloomberg field is present
 string field = "";
 if (input.Field != null) field = input.Field;
 for (int b = 0; b < barsObjectCount; b++)
 {
 // remember index of input Bars
 if (barsName[b] == component.Name + input.Series + field)
 {
 // existing Bars object
 inputBarsIndex[i] = b;
 found = true;
 break;
 }
 } // loop Bars objects
 if (!found)
 {
 // if not found in same component, search outside component
 for (int cc = 0; cc < group.Component.Length; cc++)
 {
 //if not part of combination or same as above: disregard
 if (compName[cc] == null || compName[cc] == component.Name) continue;
 for (int b = 0; b < barsObjectCount; b++)
 {
 // remember index of input Bars
 if (barsName[b] == compName[cc] + input.Series + field)
 {
 // existing Bars object
 inputBarsIndex[i] = b;
 found = true;
 break;
 }
 } // loop Bars objects
 }
 }
 
 // new Bars object
 if (!found)
 {

//-----------------------------------------------------------------------
                                    // MAKE NEW BARS / SERIES
                                    //-----------------------------------------------------------------------

//SetContext(input.Series, true); 
 bool dataset = false;
 // Check if a Dataset given
 if (input.Dataset != null) if (input.Dataset != "") dataset = true;
 if (dataset)
 bars[barsObjectCount++] =
 GetExternalSymbol(input.Dataset, input.Series, true);
 else
 if (input.Series == "Base")
 bars[barsObjectCount++] = Bars;
 else
 bars[barsObjectCount++] = 
 GetExternalSymbol(input.Series, true);
 // Bloomberg Series
 if (input.Field != null) if (input.Field != "")
 {
 DataSeries ds =
 BlmbrgF.Series(bars[barsObjectCount - 1], input.Field);
 // complicated procedure to fill Bars from DataSeries
 bars[barsObjectCount - 1] = new Bars(ds.Description, BarScale.Daily, 0);
 for (int bar = 0; bar < ds.Count; bar++)
 {
 bars[barsObjectCount - 1].Add(Bars.Date[bar],
 ds[bar], ds[bar], ds[bar], ds[bar], Bars.Volume[bar]);
 }
 }
 //RestoreContext();
 // maintain series object in parallel to bars object
 series[barsObjectCount - 1] = bars[barsObjectCount - 1].Close;
 series[barsObjectCount - 1].Description = bars[barsObjectCount - 1].Symbol;
 barsName[barsObjectCount - 1] = component.Name + input.Series + field;
 inputBarsIndex[i] = barsObjectCount - 1;
 } // new Bars object
 } // input series

//-----------------------------------------------------------------------
                            // CALL MODULE
                            //-----------------------------------------------------------------------

// bars: Bars array, barsIndex: array of Bars index
                            Modules.Module(this, bars, series, inputBarsIndex, ref barsObjectCount, 
                                parm, module.Name.ToString());

//-----------------------------------------------------------------------
                            // LOOP OUTPUT (PLOT SERIES IN PANES)
                            //-----------------------------------------------------------------------

// plot output series
 if (module.Output != null)
 {
 for (int o = 0; o < module.Output.Length; o++)
 {
 output = module.Output[o];
 int barsObjectPos = barsObjectCount - module.Output.Length + o;
 double min = series[barsObjectPos].MinValue;
 double max = series[barsObjectPos].MaxValue;
 double n = 0;
 // set output series name (overrides if "Series" Module)
 barsName[barsObjectPos] = component.Name + output.Series;

//-----------------------------------------------------------------------
                                    // PLOT IN SINGLE MODE
                                    //-----------------------------------------------------------------------

if (activeCount == 1)
 {
 if (output.Pane != "")
 {
 if (output.Pane == "Price")
 {
 PlotSeries(PricePane, series[barsObjectPos],
 color[barsObjectPos % 6], LineStyle.Solid, lineWidth);
 }
 // make pane if necessary
 else
 {
 n++;
 if (output.Pane != previousPane)
 {
 pane[paneCount++] = CreatePane(subPaneHeight, false, true);
 n = 1;
 }
 previousPane = output.Pane;
 PlotSeries(pane[paneCount - 1], series[barsObjectPos],
 color[barsObjectPos % 6], LineStyle.Solid, lineWidth);
 // draw lines
 if (module.Parameter != null)
 for (int p = 0; p < module.Parameter.Length; p++)
 {
 parameter = module.Parameter[p];
 // lines shown in previous pane !!
 if (activeCount == 1 && parameter.Name.ToString().Contains("Line"))
 DrawHorzLine(pane[paneCount - 2], parm[p],
 Color.Gold, LineStyle.Solid, 2);
 }
 }
 if (module.Output[o].Series.Contains("Step"))
 SetPaneMinMax(pane[paneCount - 1], min, max + (max - min) * n * 0.25);
 } // has output pane
 } // single

//-----------------------------------------------------------------------
                                    // PLOT IN COMBINATION MODE
                                    //-----------------------------------------------------------------------

// combination
                                    else
                                    {
                                        if (output.Pane == "Step")
                                        {
                                            pane[paneCount++] = CreatePane(stepPaneHeight, false, true);
                                            previousPane = output.Pane;
                                            PlotSeries(pane[paneCount - 1], series[barsObjectPos],
                                                color[paneCount % 6], LineStyle.Solid, lineWidth);
                                            SetPaneMinMax(pane[paneCount - 1], min, max + (max - min) * 0.25); 
                                        }
                                    } // combination   
                                } // output series
                            } // has output series
                        } // loop methods
                    } // loop components
                } // loop groups

//-----------------------------------------------------------------------
                // ZIGZAG
                //-----------------------------------------------------------------------

// zigzag vertical lines
                if (zigzag)
                {
                    // base symbol high/low series
                    DataSeries baseHighSeries = Bars.High;
                    DataSeries baseLowSeries = Bars.Low;
                    ZigZag.VerticalZigZag(this, baseHighSeries, baseLowSeries, stepPane, pane,
                                        minVertLine, maxVertLine, troughPerc, peakPerc,
                                        troughColor, peakColor, lineStyle, lineWidth);
                } // zigzag
            }
            catch (Exception e)
            {
                PrintDebug(e);
            }
        } // Execute
    }

public class StepStrategyListHelper : StrategyHelper
    {
        public override string Author
        {
            get { { return "Alexander Borg for Compass Capital"; } }
        }

public override DateTime CreationDate
        {
            get { return new DateTime(2012, 3, 26); }
        }

public override string Description
 {
 get
 {
 return
 "The <strategy> strategy " +
 "Strategy rules: " +

"Entry/Exit according to a step function (Version 1)";
 }
 }

public override Guid ID
        {
            //get the Guid String from Tools - Create Guid menu item 
            get
            {
                return new Guid("6A012439-BC9A-4E62-9A01-64C542FACF08");
            }
        }

public override DateTime LastModifiedDate
        {
            get { return new DateTime(2012, 8, 30); }
        }

public override string Name
        {
            get { { return "StepStrategy"; } }
        }

public override Type WealthScriptType
 {
 get { return typeof(StepStrategy); }
 }
 } //class <Strategy>Helper
}[/CODE]

Eugene

#4

9/6/2012 12:45 PM

There's nothing wrong with initializing the StrategyParameter[] arrays and filling them in runtime the way you do, I just double-checked. However, what happens during your Strategy execution is impossible for me to know: your 480 lines of code won't compile without 3rd party assemblies and then won't work without specific TXT/XML files. Anything can happen. When it hangs, break debugging and VS should take you right to the malfunctioning code routine.

Ben_Zurich

#5

9/10/2012 4:50 AM

Thank you for your answer. The processing never reached my breakpoints, but I have found the reason anyway:

Clicking into the sliders causes the system to hang when the corresponding strategy parameter field "Step" equals to zero.

The optimizer, on the other hand, causes the system to hang when the corresponding strategy parameter field "Start" is greater than "Stop".

The Monte Carlo method apparently doesn't use the "Step" field, and that's why I have set it to zero and run into that problem.

Eugene

#6

9/10/2012 5:03 AM

QUOTE:
Clicking into the sliders causes the system to hang when the corresponding strategy parameter field "Step" equals to zero.

Indeed, it will appear as "hung" but clicking "Cancel optimization" brings the system back to life, so no problem here.

QUOTE:
The optimizer, on the other hand, causes the system to hang when the corresponding strategy parameter field "Start" is greater than "Stop".

Exhaustive optimization? No, it's foolproof: will run once but will not hang.

You have a complex code (partially residing in external assemblies), and in this case I strongly suggest you to employ unit testing. When your code generates StrategyParameters, it can (and will) error out depending on input, so covering those procedures with unit tests could help troubleshoot this kind of code problems early.