public void Setup()
 {
     id           = Guid.NewGuid().ToString();
     stateFactory = new SimulationStateFactory(new PlantDescriptorService());
     plant        = TestPlant.CreatePlant();
     stateData    = new SimulationStateSnapshot(100);
 }
        public static void SaveMemoryUsage(string path, IPlant plant)
        {
            StringBuilder str = new StringBuilder();

            if (!File.Exists(path))
            {
                str.AppendLine("\"Part Count\";\"Cell Count\";\"Usage (MB)\"");
            }

            int cellCount = 0;

            int partCount = 0;

            var parts = new Stack <IPlantPart>(new IPlantPart[] { plant.ShootSystem.Stem, plant.RootSystem.PrimaryRoot });

            while (parts.Count > 0)
            {
                var p = parts.Pop();

                cellCount += p.Cells.Count();

                partCount++;

                foreach (var c in p.Connections)
                {
                    parts.Push(c);
                }
            }

            str.AppendLine($"\"{partCount}\";\"{cellCount}\";\"{MemoryUsage()}\"");

            File.AppendAllText(path, str.ToString(), Encoding.UTF8);
        }
Beispiel #3
0
 public AddProgressReportViewModel(IPlant plant)
 {
     Plant = plant;
     PopulateData();
     SaveCommand   = new Command(SaveReport, CanExecute);
     CancelCommand = new Command(Cancel, CanCancel);
 }
Beispiel #4
0
        private IPlant GeneratePlant(string name, int wonumber)
        {
            IPlant plant = Substitute.For <IPlant>();

            plant.Name.Returns(name);

            IMes  mes = Substitute.For <IMes>();
            IWork wo  = Substitute.For <IWork>();
            Dictionary <int, IWork> dic = new Dictionary <int, IWork>();

            wo.Id.Returns(wonumber);
            wo.Operations.Returns(new List <Op>()
            {
                new Op(Op.OpTypes.DrillOpType1)
            });
            wo.CurrentOpIndex.Returns(1);
            dic.Add(wonumber, wo);
            mes.Workorders.Returns(dic);
            plant.Mes.Returns(mes);

            IAcceptWorkorders wc = Substitute.For <IAcceptWorkorders>();

            wc.Name.Returns("Wc" + wonumber);
            wc.ListOfValidTypes().Returns(new List <Op.OpTypes>()
            {
                Op.OpTypes.DrillOpType1
            });
            plant.Workcenters.Returns(new List <IAcceptWorkorders>()
            {
                wc
            });

            return(plant);
        }
        /// <summary>
        /// Updates the model (Just one column)
        /// Updates the lists of Cultivar and Field names in the model.
        /// This is used when the model has been changed. For example, when a
        /// new crop has been selecled.
        /// </summary>
        /// <param name="model">The new model</param>
        private void UpdateModel(int propListIndex)
        {
            IGridCell curCell = this.grid.GetCurrentCell;

            for (int i = 0; i < this.properties[propListIndex].Count; i++)
            {
                IGridCell cell = this.grid.GetCell(propListIndex + 1, i); //add 1 because of Description column
                if (curCell != null && cell.RowIndex == curCell.RowIndex && cell.ColumnIndex == curCell.ColumnIndex)
                {
                    continue;
                }

                if (this.properties[propListIndex][i].Display.Type == DisplayType.CultivarName)
                {
                    IPlant crop = this.GetCrop(this.properties[propListIndex]);
                    if (crop != null)
                    {
                        cell.DropDownStrings = this.GetCultivarNames(crop);
                    }
                }
                else if (this.properties[propListIndex][i].Display.Type == DisplayType.FieldName)
                {
                    string[] fieldNames = this.GetFieldNames(propListIndex);
                    if (fieldNames != null)
                    {
                        cell.DropDownStrings = fieldNames;
                    }
                }
            }
        }
Beispiel #6
0
        void OnPlantUI(IPlant plant, PlantBase.BaseInfo info)
        {
            if (activeInfo != info && LeftMouseDown && IsMouseAround(info.position.ToVector3()))
            {
                Event.current.Use();

                CourseBase.ActivePlant = plant;
                activeInfo             = info;
                firstHit      = CourseBase.CameraTerrainHit;
                originalPoint = info.position.ToVector3();

                if (MainToolUI.SelectedTool != MainToolUI.Tool.PlantTool)
                {
                    MainToolUI.SelectedTool = MainToolUI.Tool.PlantTool;
                }
                return;
            }
            if (info == activeInfo)
            {
                RaycastHit?hit = CourseBase.CameraTerrainHit;
                if (firstHit != null && hit != null)
                {
                    PlatformBase.Editor.RecordObject(plant.Transform.gameObject, "Plant Info Position Change");

                    Vector3 position = (originalPoint + hit.Value.point - firstHit.Value.point);
                    position.y = CourseBase.TerrainHeight(position.x, position.z);

                    plant.Position = position;
                    info.position.Set(position);
                }
            }
        }
Beispiel #7
0
        /// <summary>
        /// Updates the lists of Cultivar and Field names in the model.
        /// This is used when the model has been changed. For example, when a
        /// new crop has been selecled.
        /// </summary>
        /// <param name="model">The new model</param>
        public void UpdateModel(Model model)
        {
            this.model = model;
            if (this.model != null)
            {
                IGridCell curCell = this.grid.GetCurrentCell;
                for (int i = 0; i < this.properties.Count; i++)
                {
                    IGridCell cell = this.grid.GetCell(1, i);
                    if (curCell != null && cell.RowIndex == curCell.RowIndex && cell.ColumnIndex == curCell.ColumnIndex)
                    {
                        continue;
                    }

                    if (this.properties[i].Display != null &&
                        this.properties[i].Display.Type == DisplayType.CultivarName)
                    {
                        IPlant crop = this.GetCrop(this.properties);
                        if (crop != null)
                        {
                            cell.DropDownStrings = this.GetCultivarNames(crop);
                        }
                    }
                    else if (this.properties[i].Display != null &&
                             this.properties[i].Display.Type == DisplayType.FieldName)
                    {
                        string[] fieldNames = this.GetFieldNames();
                        if (fieldNames != null)
                        {
                            cell.DropDownStrings = fieldNames;
                        }
                    }
                }
            }
        }
 public GenericPlantRunner(IPlant plant, SimulationEnvironment environment, IPlantGrower plantGrower, FluidsPlantCycle sucroseCycle)
 {
     this.plantGrower  = plantGrower;
     this.sucroseCycle = sucroseCycle;
     Plant             = plant;
     Environment       = environment;
 }
 public GenericCellGrower(IPlant plant, SimulationEnvironment environment, ICellBodySystemSolver systemSolver, IPlantSimulatorOptionsService optionsService)
 {
     this.plant          = plant;
     this.environment    = environment;
     this.systemSolver   = systemSolver;
     this.optionsService = optionsService;
 }
Beispiel #10
0
        private bool PopulateData(IPlant plant)
        {
            SaveCommand   = new Command(Save, CanSave);
            CancelCommand = new Command(Cancel, CanCancel);

            try
            {
                Strains   = Strain.FindAll().OrderBy(x => x.Name);
                Schedules = Schedule.FindAll().OrderBy(x => x.Name);
                Gardens   = Garden.FindAll().OrderBy(x => x.Name);

                if (plant == null)
                {
                    Plant = new Plant();
                    return(true);
                }

                Plant            = Plant.Find(plant.Id);
                SelectedSchedule = Schedules.Where(x => x.Id == plant.ScheduleId).FirstOrDefault();
                SelectedStrain   = Strains.Where(x => x.Id == plant.Strain.Id).FirstOrDefault();
                SelectedGarden   = Gardens.Where(x => x.Id == plant.GardenId).SingleOrDefault();
                _isDirty         = false;
                return(true);
            }
            catch (Exception)
            {
                return(false);
            }
        }
        protected void SetUp()
        {
            Test test = new Test("Default", 0, 0, 0, 0, 0);

            Configuration.Initialize(test);

            _workorder = Substitute.For <IWork>();
            _workorder.CurrentOpType.Returns(Op.OpTypes.DrillOpType1);
            _workorder.CurrentOpSetupTime.Returns(0);
            _workorder.CurrentOpEstTimeToComplete.Returns(1);
            _workorder.Id.Returns(1);

            ISchedulePlants ps = Substitute.For <ISchedulePlants>();

            ps.ValidateWoForMachines(Arg.Any <int>(), Arg.Any <string>()).Returns(x => x[0]);
            _plant = Substitute.For <IPlant>();
            _plant.PlantScheduler.Returns(ps);

            _bigData = Substitute.For <IHandleBigData>();
            _bigData.IsBreakdown(Arg.Any <string>(), Arg.Any <DayTime>()).Returns(x => x[1]);
            _bigData.IsNonConformance(Arg.Any <string>()).Returns(false);

            _mes     = Substitute.For <IMes>();
            _dayTime = new DayTime();
            _subject = new Workcenter("TestWC", Machine.Types.BigDrill);
            _subject.SetMes(_mes);

            _subject.AddPlant(_plant);
            _subject.AddBigData(_bigData);
        }
Beispiel #12
0
 protected new void DestroyOrganism()
 {
     base.DestroyOrganism();
     eatable    = false;
     plantFuncs = null;
     grownWatch.Stop();
 }
        public static void CollectInput(Farm farm, IPlant sunflower)
        {
            Utils.Clear();

            try
            {
                for (int i = 1; i <= farm.PlantFields.Count; i++)
                {
                    IPlantable field = farm.PlantFields[i - 1];
                    if (field.Capacity > field.numOfPlants())
                    {
                        Console.WriteLine($"{i}. {field.Type} {field.shortId()} has {field.numOfPlants() / field.PlantsPerRow } rows of plants.");

                        // Print out the counts of each type of animal
                        var counts = field.Plants.GroupBy(plant => plant.Type)
                                     .Select(group => new PrintReport
                        {
                            Name  = group.Key,
                            Count = group.Count()
                        });

                        foreach (PrintReport report in counts)
                        {
                            Console.WriteLine($"{report.Name}: {report.Count}");
                        }
                    }
                    else
                    {
                        Console.WriteLine($"{i}. {farm.PlantFields[i-1].Type} {farm.PlantFields[i-1].shortId()} is at capacity with {farm.PlantFields[i - 1].numOfPlants()} plants.");
                    }
                }

                // for (int i = 1; i <= farm.PlantFields.Count; i++) {
                //     Console.WriteLine($"{i}. {farm.PlantFields[i - 1].Type} {farm.PlantFields[i - 1].shortId()} has {farm.PlantFields[i - 1].numOfPlants()} plants.");
                // }

                Console.WriteLine();

                // How can I output the type of seed chosen here?
                Console.WriteLine($"Place the plant where?");

                Console.Write("> ");
                int choice = Int32.Parse(Console.ReadLine());

                farm.PlantFields[choice - 1].AddResource(sunflower);
            }
            catch
            {
                Console.WriteLine("Please enter a valid selection.");
                Thread.Sleep(1000);
                CollectInput(farm, sunflower);
            }


            /*
             *  Couldn't get this to work. Can you?
             *  Stretch goal. Only if the app is fully functional.
             */
            // farm.PurchaseResource<IGrazing>(animal, choice);
        }
        protected void SetUp()
        {
            _plant1 = Substitute.For <IPlant>();
            _plant1.Name.Returns(PLANT1_NAME);
            IMes            mes1 = Substitute.For <IMes>();
            ISchedulePlants isp1 = Substitute.For <ISchedulePlants>();

            _plant1.Mes.Returns(mes1);
            _plant1.PlantScheduler.Returns(isp1);
            _plant1.Workcenters.Returns(new List <IAcceptWorkorders>());

            _plant2 = Substitute.For <IPlant>();
            _plant2.Name.Returns(PLANT2_NAME);
            IMes            mes2 = Substitute.For <IMes>();
            ISchedulePlants isp2 = Substitute.For <ISchedulePlants>();

            _plant2.Mes.Returns(mes2);
            _plant2.PlantScheduler.Returns(isp2);
            _plant2.Workcenters.Returns(new List <IAcceptWorkorders>());

            List <IPlant> list = new List <IPlant>()
            {
                _plant1, _plant2
            };

            _subject = new Erp(ERP_NAME);
            _subject.Add(_plant1);
            _subject.Add(_plant2);
        }
Beispiel #15
0
        static void Write(IPlant plant, ICompany company)
        {
            Multicast writeInfo = plant.Write_Plant;

            writeInfo += company.Write_Company;
            writeInfo();
        }
 public void Setup()
 {
     environment = new SimulationEnvironment {
         LightPosition = new Vertex(0, 10000, 0), Temperature = 22
     };
     plant                         = TestPlant.CreatePlant();
     cellFactory                   = new GenericCellFactory();
     optionsService                = PlantSimulatorOptionsHelper.CreateOptionsService();
     divider                       = new GenericCellDivider(cellFactory);
     helper                        = new GeometryHelper();
     cellSizer                     = new GenericCellSizer(helper, new LoggerAdapter <GenericCellSizer>(new NullLogger <GenericCellSizer>()));
     cellCollisionDetection        = new CellCollisionDetection(helper);
     bodySystemSolver              = new GenericCellBodySystemSolver(cellCollisionDetection, cellSizer);
     cellGrower                    = new GenericCellGrower(plant, environment, bodySystemSolver, optionsService);
     descriptorService             = new PlantDescriptorService();
     cellCreator                   = new HexagonCellCreator(cellFactory);
     gridCreator                   = new HexagonalCellGridFactory(cellCreator, CornCellTypeLocator.GetCornCellTypeLocator(), optionsService);
     plantPartCellCreator          = new PlantPartCellCreator(gridCreator);
     internodePartFactory          = new GenericInternodePartFactory(optionsService, gridCreator);
     stemPartFactory               = new GenericStemPartFactory(optionsService, internodePartFactory);
     petiolePartFactory            = new GenericPetiolePartFactory(cellFactory, optionsService);
     nodePartFactory               = new GenericNodePartFactory(optionsService, cellFactory, stemPartFactory, petiolePartFactory);
     internodePlantPartDevelopment = new InternodePartDevelopment(optionsService, nodePartFactory, cellGrower, descriptorService, internodePartFactory);
     rootFactory                   = new GenericRootPartFactory(optionsService, plantPartCellCreator);
     rootPlantPartDevelopment      = new RootPartDevelopment(optionsService, nodePartFactory, rootFactory, cellGrower, descriptorService);
     developer                     = new PlantPartDeveloper(internodePlantPartDevelopment, rootPlantPartDevelopment);
     sucroseCarrierCollection      =
         new SucroseCarrierCollection(
             new LoggerAdapter <SucroseCarrierCollection>(new NullLogger <SucroseCarrierCollection>()));
     sucroseTransporter     = new SucroseTransporter(cellCollisionDetection, helper, sucroseCarrierCollection, new LoggerAdapter <FluidTransporter <Sucrose> >(new NullLogger <FluidTransporter <Sucrose> >()));
     plantGrower            = new GenericPlantGrower(bodySystemSolver, developer, sucroseTransporter);
     runner                 = new GenericPlantRunner(plant, environment, plantGrower, new FluidsPlantCycle(plant, optionsService, sucroseCarrierCollection, new LoggerAdapter <FluidsPlantCycle>(new NullLogger <FluidsPlantCycle>())));
     RangeExtensions.Random = new Random(optionsService.Options.Simulation.RandomSeed);
 }
        public IPlant Grow()
        {
            IPlant plant = _seedBank.Identify(this);

            plant.Plant(_soil);

            return(plant.Grow());
        }
Beispiel #18
0
 public EditPlantViewModel(IPlant plant)
 {
     if (!PopulateData(plant))
     {
         Plant    = new Plant();
         _isDirty = false;
     }
 }
Beispiel #19
0
 private PlantModelState CreatePlantState(IPlant plant)
 {
     return(new PlantModelState
     {
         ShootSystem = CreateShootState(plant.ShootSystem),
         RootSystem = CreateRootState(plant.RootSystem)
     });
 }
Beispiel #20
0
        public void AddPlant(IPlant plant)
        {
            if (_plant != null)
            {
                return;
            }

            _plant = plant;
        }
Beispiel #21
0
        public int EatPlant(IPlant p)
        {
            if (p != null)
            {
                return(p.GetEatenQuantity(this.biteSize));
            }

            return(0);
        }
Beispiel #22
0
 public SimulationState Create(string id, IPlant plant, SimulationStateSnapshot data)
 {
     return(new SimulationState
     {
         Id = id,
         SimulationTime = data.CurrentTime,
         Plant = CreatePlantState(plant)
     });
 }
 public FluidsPlantCycle(IPlant plant, IPlantSimulatorOptionsService optionsService,
                         ICarrierCollection <Sucrose> sucroseCarrierCollection, ILoggerAdapter <FluidsPlantCycle> logger)
 {
     this.plant                    = plant;
     this.optionsService           = optionsService;
     this.sucroseCarrierCollection = sucroseCarrierCollection;
     this.logger                   = logger;
     random = new Random(optionsService.Options.Simulation.RandomSeed);
 }
        public int EatPlant(IPlant plant)
        {
            if (plant != null)
            {
                ++this.Size;
                return(plant.GetEatenQuantity(this.biteSize));
            }

            return(0);
        }
Beispiel #25
0
        public static void CollectInput(Farm farm, IPlant plant)
        {
            Utils.Clear();
            try {
                for (int i = 1; i <= farm.NaturalFields.Count; i++)
                {
                    NaturalField field = farm.NaturalFields[i - 1];
                    if (field.Capacity > field.numOfPlants())
                    {
                        Console.WriteLine($"{i}. Natural Field {field.shortId()} has {(field.numOfPlants() / 6)} rows of plants.");

                        // Print out the counts of each type of animal
                        var counts = field.Plants.GroupBy(plant => plant.Type)
                                     .Select(group => new PrintReport {
                            Name  = group.Key,
                            Count = group.Count()
                        });

                        foreach (PrintReport report in counts)
                        {
                            Console.WriteLine($"{report.Name}: {report.Count}");
                        }
                    }
                    else
                    {
                        Console.WriteLine($"{i}. Natural Field {field.shortId()} is at capacity with {field.numOfPlants()} plants.");
                        // Print out the counts of each type of animal
                        var counts = field.Plants.GroupBy(plant => plant.Type)
                                     .Select(group => new PrintReport {
                            Name  = group.Key,
                            Count = group.Count()
                        });

                        foreach (PrintReport report in counts)
                        {
                            Console.WriteLine($"{report.Name}: {report.Count}");
                        }
                    }
                }

                Console.WriteLine();

                // How can I output the type of seed chosen here?
                Console.WriteLine($"Place the plant where?");

                Console.Write("> ");
                int choice = Int32.Parse(Console.ReadLine());

                farm.NaturalFields[choice - 1].AddResource(plant);
            } catch {
                Console.WriteLine("Please enter a valid selection.");
                Thread.Sleep(1000);
                CollectInput(farm, plant);
            }
        }
Beispiel #26
0
        public virtual void Process(InitializePlantArgs args)
        {
            IPlant plant = args.IPlantObject;

            if (plant.Description.IsNullOrEmpty() || plant.HumanSupportingName.IsNullOrEmpty())
            {
                Log.Warn("Plant '{0}' doesn't provide correct name and description. It will be disabed".FormatWith(args.PlantID), this);
                args.Abort();
                args.ResolvedPlantEx = null;
            }
        }
        /// <summary>Get a list of cultivars for crop.</summary>
        /// <param name="crop">The crop.</param>
        /// <returns>A list of cultivars.</returns>
        public static string[] GetCultivarNames(IPlant crop)
        {
            Simulations  simulations  = (crop as IModel).FindAncestor <Simulations>();
            Replacements replacements = simulations.FindChild <Replacements>();

            if (replacements == null)
            {
                return(crop.CultivarNames);
            }

            IPlant replacementCrop = replacements.FindChild((crop as IModel).Name) as IPlant;

            if (replacementCrop != null)
            {
                return(replacementCrop.CultivarNames);
            }

            // Check for cultivar folders under replacements.
            List <string> cultivarNames = crop.CultivarNames.ToList();

            foreach (CultivarFolder cultivarFolder in (crop as IModel).FindAllChildren <CultivarFolder>())
            {
                IModel replacementFolder = replacements.FindChild(cultivarFolder.Name);
                if (replacementFolder != null)
                {
                    // If we find a matching cultivar folder under replacements, remove
                    // all cultivar names added by this folder in the official plant
                    // model, and add the cultivar names added by the matching cultivar
                    // folder under replacements.
                    foreach (IModel cultivar in cultivarFolder.FindAllDescendants <Cultivar>())
                    {
                        cultivarNames.Remove(cultivar.Name);

                        // If the cultivar has memo children, then the memo text will
                        // be appended to the cultivar name after a vertical bar |.
                        // Technically, there could be a cultivar x and x|y, but the UI
                        // will prevent users from doing this, so the user would really
                        // just be digging their own hole at this point.
                        cultivarNames.RemoveAll(c => c.StartsWith(cultivar.Name + "|"));
                    }

                    foreach (Alias alias in cultivarFolder.FindAllDescendants <Alias>())
                    {
                        cultivarNames.RemoveAll(c => c.StartsWith(alias.Name + "|"));
                    }

                    foreach (IModel cultivar in replacementFolder.FindAllDescendants <Cultivar>())
                    {
                        cultivarNames.Add(cultivar.Name);
                    }
                }
            }
            return(cultivarNames.ToArray());
        }
Beispiel #28
0
        protected void Setup()
        {
            _dayTime = new DayTime();
            _plant1  = GeneratePlant("P1", 1);
            _plant2  = GeneratePlant("P2", 2);

            //List<IPlant> list = new List<IPlant>() { _plant1, _plant2 };
            _customer = new Customer();

            _subject = new Enterprise(_customer);
            _subject.Add(_plant1);
            _subject.Add(_plant2);
        }
Beispiel #29
0
        public static void Print(object obj)
        {
            IPlant plant = obj as IPlant;

            if (plant as IPlant != null)
            {
                Print(plant);
            }
            else
            {
                Console.WriteLine("---------------Print for " + obj.GetType() + "---------------");
                Console.WriteLine(obj.ToString());
            }
        }
        public virtual void Process(InitializePlantArgs args)
        {
            IPlant plant = args.IPlantObject;

            try
            {
                plant.Initialize();
            }
            catch (Exception ex)
            {
                Log.Error("Unable to initialize plant {0}".FormatWith(plant.GetType()), ex, this);
                args.Abort();
            }
        }
Beispiel #31
0
 public Rabbit(IPlant food)
 {
     this.Food = food;
 }
Beispiel #32
0
 public Plant(IPlant plant)
     : base(plant)
 {
 }
Beispiel #33
0
 public void DoSomething(IPlant plant)
 {
     Console.WriteLine(String.Format("{0} has a soil moisture of {1}% and needs some water", plant.Name, plant.SoilMoisture));
 }