private ISorterCompParaPoolWorkflow EvaluateResultsStep(int seed)
        {
            var sorterLayerEval =
                CompParaPool.SorterOnSwitchableGroupSets.Select(
                    t => GenomeEval.Make(
                        genome: SorterLayer.GetGenome(t.Sorter.Guid),
                        score:  t.SwitchesUsed,
                        generation: Generation,
                        success: t.SorterOnSwitchableGroups.All(sg => sg.Success)
                        )
                    ).Make <ISorterGenome, IGenomeEval <ISorterGenome> >();


            var switchableGroupLayerEval =
                CompParaPool.SorterOnSwitchableGroups.GroupBy(t => t.SwitchableGroupGuid).Select(
                    g => GenomeEval.Make(
                        genome: SwitchableGroupLayer.GetGenome(g.Key),
                        score: g.Sum(s => - s.SwitchUseCount),
                        generation: Generation,
                        success: g.All(m => m.Success)
                        )
                    ).Make <ISwitchableGroupGenome, IGenomeEval <ISwitchableGroupGenome> >();

            return(new SorterCompParaPoolWorkflowImpl
                   (
                       compWorkflowState: CompWorkflowState.UpdateGenomes,
                       sorterLayer: SorterLayer,
                       switchableGroupLayer: SwitchableGroupLayer,
                       compParaPool: CompParaPool,
                       sorterLayerEval: sorterLayerEval,
                       switchableGroupLayerEval: switchableGroupLayerEval,
                       sorterCompParaPoolParams: SorterCompParaPoolParams,
                       generation: Generation
                   ));
        }
        private IScpWorkflow EvaluateResultsStep(int seed)
        {
            Func <ISorterEval, double> evalFunc;

            evalFunc = ev => ev.SwitchUseCount
                       +
                       ev.Reduce(guid: Guid.NewGuid()).ToStagedSorter().SorterStages.Count / 1000;

            //evalFunc = ev => ev.SwitchUseCount;

            //if (Generation % 10 < 5)
            //{
            //    evalFunc = ev => ev.Reduce(guid: Guid.NewGuid()).ToStagedSorter().SorterStages.Count;
            //}
            //else
            //{
            //    evalFunc = ev => ev.SwitchUseCount;
            //}

            var sorterLayerEval =
                CompPool.SorterEvals
                .Where(t => SorterLayer1.GetGenome(t.Sorter.Guid) != null)
                .Select(
                    t => GenomeEval.Make(
                        genome: SorterLayer1.GetGenome(t.Sorter.Guid),
                        score: evalFunc(t),
                        generation: Generation,
                        success: t.Success
                        )
                    ).Concat(SorterLayerEval.GenomeEvals)
                .Make <ISorterGenome, IGenomeEval <ISorterGenome> >();


            return(new ScpWorkflowImpl
                   (
                       compWorkflowState: CompWorkflowState.UpdateGenomes,
                       sorterLayer0: SorterLayer0,
                       sorterLayer1: _sorterLayer1,
                       compPool: CompPool,
                       sorterLayerEval: sorterLayerEval,
                       scpParams: ScpParams,
                       generation: Generation,
                       report: string.Empty
                   ));
        }