public EnvironmentImpactedBase(Strat strat_, Calculator calculator_)
   : base(strat_)
 {
   EnvironCalc = calculator_;
 }
 protected EnvironBacktestBase(Strat thisStrat_, Calculator calculator_)
   : base(thisStrat_)
 {
   Calculator = calculator_;
 }
    public ParameterSets()
    {
      Logger.Debug("Creating parameters sets for Breakout strategy",typeof(ParameterSets));

      var thresholds = new[]
      {
        2d,
        2.5d,
        3d,
        3.5d,
      };

      const IndicType indicator = IndicType.CcyMultiUniverse;

      var contextMAsToScoreWindowLengths = new Dictionary<int, int[]>
      {
        {126, new[] {42, 63, 84}},
        {252, new[] {63, 84, 126}}
      };


      const EnvironmentContextType contextType = EnvironmentContextType.MA;

      foreach (var contextMA in contextMAsToScoreWindowLengths.Keys)
      {
        foreach (var scoreWindowLength in contextMAsToScoreWindowLengths[contextMA])
        {
          if (scoreWindowLength >= contextMA)
            continue;

          foreach (var threshold in thresholds)
          {
            var calc = new Calculator
            {
              Offset = 0,
              EnvironmentSourceTransform = EnvironmentSourceTransformType.Score,
              ScoreWindow = scoreWindowLength,
              ContextType = contextType,
              ContextMAWindow = contextMA,
              EnvironmentSource = EnvironmentSourceType.Defined,
              IndicType = indicator
            };


            calc.Affectors.Add(new IndicRangeAffect()
            {
              Inc = 0.25,
              RangeStart = -100d,
              RangeEnd = -threshold,
              Target = 1d
            });
            calc.Affectors.Add(new IndicRangeAffect()
            {
              Inc = 0.25,
              RangeStart = -threshold,
              RangeEnd = threshold,
              Target = 0d
            });
            calc.Affectors.Add(new IndicRangeAffect()
            {
              Inc = 0.25,
              RangeStart = threshold,
              RangeEnd = 100d,
              Target = -1d
            });

            EnvironIndic.MultiCcyIndicator.CurrencyMultiScore underlying=null;

            Logger.Debug(string.Format("Getting Universe Score with length {0}", scoreWindowLength),
              typeof (ParameterSets));

            switch (scoreWindowLength)
            {
              case 42:
                underlying = Singleton<CurrencyUniverseScore_42>.Instance;
                break;
              case 63:
                underlying = Singleton<CurrencyUniverseScore_63>.Instance;
                break;
              case 84:
                underlying = Singleton<CurrencyUniverseScore_84>.Instance;
                break;
              case 126:
                underlying = Singleton<CurrencyUniverseScore_126>.Instance;
                break;
              default:
                throw new Exception("case not handled");
            }

            Logger.Debug(string.Format("Getting context score with length {0}", contextMA), typeof (ParameterSets));

            EnvironIndic.MultiCcyIndicator.CurrencyMultiScore contextObject = null;

            switch (contextMA)
            {
              case 126:
                contextObject = Singleton<CurrencyUniverseScore_126>.Instance;
                break;
              case 252:
                contextObject = Singleton<CurrencyUniverseScore_252>.Instance;
                break;
            }

            m_sets.Add(new ParameterSet(calc, underlying.LiveObject, contextObject.LiveObject));
          }
        }
      }

      foreach (var se in m_sets)
        se.PropertyChanged += (a, b) =>
        {
          if (string.CompareOrdinal("TodayMult", b.PropertyName) == 0)
            Notify("AvgAllocation");
        };
    }