protected override void Context() { _sensitivityAnalysisTask = A.Fake <ISensitivityAnalysisTask>(); _simulationAnalyzer = A.Fake <ISimulationAnalyzer>(); _parameterSelector = A.Fake <IParameterAnalysableParameterSelector>(); _containerTask = A.Fake <IContainerTask>(); _simulation = A.Fake <ISimulation>(); _sensitivityAnalysis = new SensitivityAnalysis(_simulation); _coreSensitivityAnalysis = new Core.Domain.SensitivityAnalyses.SensitivityAnalysis(); sut = new SensitivityAnalysisToCoreSensitivityAnalysisMapper(_sensitivityAnalysisTask, _simulationAnalyzer, _parameterSelector, _containerTask); _constantParameterCache = new PathCacheForSpecs <IParameter> { { _parameterPath1, DomainHelperForSpecs.ConstantParameterWithValue(10).WithName("P1") }, { _parameterPath2, DomainHelperForSpecs.ConstantParameterWithValue(10).WithName("P2") }, { _parameterPath3, DomainHelperForSpecs.ConstantParameterWithValue(10).WithName("P3") } }; A.CallTo(() => _sensitivityAnalysisTask.CreateSensitivityAnalysisFor(_simulation)).Returns(_coreSensitivityAnalysis); A.CallTo(_containerTask).WithReturnType <PathCache <IParameter> >().Returns(_constantParameterCache); _allSensitivityParametersCreated = new List <ParameterSelection>(); A.CallTo(() => _sensitivityAnalysisTask.AddParametersTo(_coreSensitivityAnalysis, A <IReadOnlyList <ParameterSelection> > ._)) .Invokes(x => _allSensitivityParametersCreated.AddRange(x.GetArgument <IReadOnlyList <ParameterSelection> >(1))); }
protected override void Context() { _view = A.Fake <IParameterIdentificationSimulationSelectionView>(); _treeNodeFactory = A.Fake <ITreeNodeFactory>(); _applicationController = A.Fake <IApplicationController>(); _lazyLoadTask = A.Fake <ILazyLoadTask>(); _treeNodeContextMenuFactory = A.Fake <ITreeNodeContextMenuFactory>(); _multipleTreeNodeContextMenuFactory = A.Fake <IMultipleTreeNodeContextMenuFactory>(); _dialogCreator = A.Fake <IDialogCreator>(); _parameterIdentificationTask = A.Fake <IParameterIdentificationTask>(); sut = new ParameterIdentificationSimulationSelectionPresenter(_view, _treeNodeFactory, _applicationController, _lazyLoadTask, _treeNodeContextMenuFactory, _multipleTreeNodeContextMenuFactory, _dialogCreator, _parameterIdentificationTask); _parameterIdentification = new ParameterIdentification(); _simulation = A.Fake <ISimulation>().WithId("Id").WithName("S"); _parameterIdentification.AddSimulation(_simulation); _outputMapping = new OutputMapping { OutputSelection = new SimulationQuantitySelection(_simulation, new QuantitySelection("PATH", QuantityType.Drug)) }; _parameterIdentification.AddOutputMapping(_outputMapping); _simulationNode = A.Fake <ITreeNode>(); A.CallTo(() => _treeNodeFactory.CreateFor(_simulation)).Returns(_simulationNode); _simulationSelectionPresenter = A.Fake <ISelectionSimulationPresenter>(); A.CallTo(() => _applicationController.Start <ISelectionSimulationPresenter>()).Returns(_simulationSelectionPresenter); sut.EditParameterIdentification(_parameterIdentification); }
protected override void Context() { _oldSimulation = A.Fake <ISimulation>(); sut = new SensitivityAnalysis { Simulation = _oldSimulation }; }
// Schedule() implementation for ITriggerEventsJob when Havok Physics is available public static unsafe JobHandle Schedule <T>(this T jobData, ISimulation simulation, ref PhysicsWorld world, JobHandle inputDeps) where T : struct, ITriggerEventsJob { switch (simulation.Type) { case SimulationType.UnityPhysics: // Call the scheduling method for Unity.Physics return(ITriggerEventJobExtensions.ScheduleUnityPhysicsTriggerEventsJob(jobData, simulation, ref world, inputDeps)); case SimulationType.HavokPhysics: { var data = new TriggerEventJobData <T> { UserJobData = jobData, EventReader = ((Havok.Physics.HavokSimulation)simulation).TriggerEvents }; // Ensure the input dependencies include the end-of-simulation job, so events will have been generated inputDeps = JobHandle.CombineDependencies(inputDeps, simulation.FinalSimulationJobHandle); var parameters = new JobsUtility.JobScheduleParameters( UnsafeUtility.AddressOf(ref data), TriggerEventJobProcess <T> .Initialize(), inputDeps, ScheduleMode.Batched); return(JobsUtility.Schedule(ref parameters)); } default: return(inputDeps); } }
// Use this for initialization void Start() { hair = HairFactory.GrowHairOnDefinedPos(50, 1f, new List <Vector3>(ScalpMF.sharedMesh.vertices), 0.01f); Visualizer.Init(gameObject.GetComponent <MeshFilter>()); sim = new FTL(hair); sim.AddForce(new Vector3(5, 0, 0)); }
// Schedule() implementation for IContactsJob when Havok Physics is available public static unsafe JobHandle Schedule <T>(this T jobData, ISimulation simulation, ref PhysicsWorld world, JobHandle inputDeps) where T : struct, IContactsJobBase { switch (simulation.Type) { case SimulationType.UnityPhysics: // Call the scheduling method for Unity.Physics return(IContactsJobExtensions.ScheduleUnityPhysicsContactsJob(jobData, simulation, ref world, inputDeps)); case SimulationType.HavokPhysics: { var data = new ContactsJobData <T> { UserJobData = jobData, ManifoldStream = ((Havok.Physics.HavokSimulation)simulation).ManifoldStream, PluginIndexToLocal = ((Havok.Physics.HavokSimulation)simulation).PluginIndexToLocal, Bodies = world.Bodies }; var parameters = new JobsUtility.JobScheduleParameters( UnsafeUtility.AddressOf(ref data), ContactsJobProcess <T> .Initialize(), inputDeps, ScheduleMode.Batched); return(JobsUtility.Schedule(ref parameters)); } default: return(inputDeps); } }
/// <summary> /// Initializes a new instance of the <see cref="BindingContext"/> class. /// </summary> /// <param name="entity">The entity creating the behavior.</param> /// <param name="simulation">The simulation for which a behavior is created.</param> /// <param name="behaviors">The behavior container.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="entity"/> or <paramref name="simulation"/> is <c>null</c>.</exception> public BindingContext(IEntity entity, ISimulation simulation, IBehaviorContainer behaviors) { Entity = entity.ThrowIfNull(nameof(entity)); Simulation = simulation.ThrowIfNull(nameof(simulation)); Behaviors = behaviors; _cloned = entity.LinkParameters ? null : new Dictionary <IParameterSet, IParameterSet>(); }
private void FileOpen(string fileName) { if (string.IsNullOrEmpty(fileName)) { openSimulationFileDialog.InitialDirectory = AppDomain.CurrentDomain.BaseDirectory; if (openSimulationFileDialog.ShowDialog(this) == DialogResult.OK) { fileName = openSimulationFileDialog.FileName; } } if (!string.IsNullOrEmpty(fileName)) { this.ClearSimulation(); _simulation = new LangtonsAntSimulation(this); try { this.SetStatus("Loading simulation..."); _simulation.Load(fileName); _simulationFileName = fileName; this.InitializeSimulation(_simulation); } catch (Exception ex) { MessageBox.Show(string.Format("Failed to open simulation. {0}", ex.Message), Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Exclamation); } finally { this.SetStatus(string.Empty); } } }
private void addPKParametersForOutput(ISimulation simulation, int numberOfIndividuals, SimulationResults runResults, Action <int> performIndividualScalingAction, QuantitySelection selectedQuantity, PopulationSimulationPKAnalyses popAnalyses, string moleculeName, PKCalculationOptions pkCalculationOptions, IReadOnlyList <PKCalculationOptionsFactory.ApplicationParameters> allApplicationParameters) { var availablePKParameters = _pkParameterRepository.All().Where(p => PKParameterCanBeUsed(p, pkCalculationOptions)).ToList(); //create pk parameter for each quantities foreach (var pkParameter in availablePKParameters) { var quantityPKParameter = new QuantityPKParameter { Name = pkParameter.Name, QuantityPath = selectedQuantity.Path, Dimension = pkParameter.Dimension }; quantityPKParameter.SetNumberOfIndividuals(numberOfIndividuals); popAnalyses.AddPKAnalysis(quantityPKParameter); } //add the values for each individual foreach (var individualResult in runResults.AllIndividualResults) { performIndividualScalingAction(individualResult.IndividualId); _pkCalculationOptionsFactory.UpdateAppliedDose(simulation, moleculeName, pkCalculationOptions, allApplicationParameters); var values = individualResult.ValuesFor(selectedQuantity.Path); var pkValues = _pkValuesCalculator.CalculatePK(individualResult.Time.Values, values.Values, pkCalculationOptions); foreach (var pkParameter in availablePKParameters) { var quantityPKParameter = popAnalyses.PKParameterFor(selectedQuantity.Path, pkParameter.Name); quantityPKParameter.SetValue(individualResult.IndividualId, pkValues.ValueOrDefaultFor(pkParameter.Name)); } } }
static void Main(string[] args) { ISimulation sim = Simulation.getInstance(); sim.Display = Display.getInstance(); sim.Start(); }
protected override void Context() { base.Context(); _simulation = A.Fake <ISimulation>(); _runResults = A.Fake <SimulationResults>(); var outputSelections = new OutputSelections(); outputSelections.AddOutput(new QuantitySelection("Liver|Cell|Drug|Concentration", QuantityType.Drug)); A.CallTo(() => _simulation.OutputSelections).Returns(outputSelections); var pKCalculationOptions = new PKCalculationOptions(); A.CallTo(_pkCalculationOptionsFactory).WithReturnType <PKCalculationOptions>().Returns(pKCalculationOptions); _p1 = new PKParameter().WithName("AUC"); _p1.Mode = PKParameterMode.Single; _p2 = new PKParameter().WithName("AUC" + Constants.PKParameters.NormSuffix); _p2.Mode = PKParameterMode.Single; A.CallTo(() => _pkParameterRepository.All()).Returns(new[] { _p1, _p2 }); var individualResults = A.Fake <IndividualResults>(); A.CallTo(() => _runResults.AllIndividualResults).Returns(new HashSet <IndividualResults>(new [] { individualResults })); var pKValues = new PKValues(); pKValues.AddValue(_p1.Name, 10f); pKValues.AddValue(_p2.Name, 20f); A.CallTo(_pkValuesCalculator).WithReturnType <PKValues>().Returns(pKValues); }
private void addSimulationToView(ISimulation simulation) { _lazyLoadTask.Load(simulation); var simulationNode = _treeNodeFactory.CreateFor(simulation); _view.AddNode(simulationNode); }
protected override void Context() { _cloneManager = A.Fake <ICloneManagerForModel>(); _simulationFactory = A.Fake <ICoreSimulationFactory>(); _parameterIdentificationRun = A.Fake <IParameterIdentificationRun>(); _coreUserSettings = A.Fake <ICoreUserSettings>(); _descriptionCreator = A.Fake <ICategorialParameterIdentificationDescriptionCreator>(); _container = A.Fake <Utility.Container.IContainer>(); A.CallTo(() => _container.Resolve <ICoreSimulationFactory>()).Returns(_simulationFactory); _coreUserSettings.MaximumNumberOfCoresToUse = 1; sut = new CategorialParameterIdentificationRunInitializer(_cloneManager, _parameterIdentificationRun, _container, _descriptionCreator, _coreUserSettings); _parameterIdentification = new ParameterIdentification(); _parameterIdentification.Configuration.RunMode = new CategorialParameterIdentificationRunMode(); _simulation = A.Fake <ISimulation>(); _clonedSimulation = A.Fake <ISimulation>(); A.CallTo(() => _simulationFactory.CreateWithCalculationMethodsFrom(_simulation, A <IEnumerable <CalculationMethodWithCompoundName> > ._)).Returns(_clonedSimulation); A.CallTo(() => _cloneManager.Clone(_parameterIdentification)).ReturnsLazily(() => { var pi = new ParameterIdentification(); pi.AddSimulation(_simulation); var identificationParameter = new IdentificationParameter(); identificationParameter.AddLinkedParameter(new ParameterSelection(_simulation, A.Fake <QuantitySelection>())); pi.AddIdentificationParameter(identificationParameter); pi.AddOutputMapping(new OutputMapping { OutputSelection = new SimulationQuantitySelection(_simulation, A.Fake <QuantitySelection>()) }); pi.Configuration.RunMode = new CategorialParameterIdentificationRunMode(); return(pi); }); }
protected override void Context() { base.Context(); _simulation = A.Fake <ISimulation>(); _runResults = A.Fake <SimulationResults>(); var outputSelections = new OutputSelections(); outputSelections.AddOutput(new QuantitySelection("Liver|Cell|Drug|Concentration", QuantityType.Drug)); A.CallTo(() => _simulation.OutputSelections).Returns(outputSelections); var pKCalculationOptions = new PKCalculationOptions(); A.CallTo(_pkCalculationOptionsFactory).WithReturnType <PKCalculationOptions>().Returns(pKCalculationOptions); _p1 = new PKParameter { Name = "AUC", Mode = PKParameterMode.Single }; _userDefinedParameter1 = new UserDefinedPKParameter { Name = "Dynamic1", Mode = PKParameterMode.Single }; A.CallTo(() => _pkParameterRepository.All()).Returns(new[] { _p1, _userDefinedParameter1 }); var individualResults = A.Fake <IndividualResults>(); A.CallTo(() => _runResults.AllIndividualResults).Returns(new HashSet <IndividualResults>(new[] { individualResults })); var pKValues = new PKValues(); pKValues.AddValue(_p1.Name, 10f); pKValues.AddValue(_userDefinedParameter1.Name, 30f); A.CallTo(_pkValuesCalculator).WithReturnType <PKValues>().Returns(pKValues); }
protected override void Context() { sut = new OutputMappingToOutputMappingDTOMapper(); _simulation = A.Fake <ISimulation>(); _availableOutputs = new List <SimulationQuantitySelectionDTO>(); _outputMapping = new OutputMapping(); }
/// <inheritdoc/> public override void CreateBehaviors(ISimulation simulation) { var behaviors = new BehaviorContainer(Name); if (Parameters.Entities != null || Parameters.Entities.Count > 0) { // Create our local simulation and binding context to allow behaviors to do stuff var localSim = new ParallelSimulation(simulation, this); var context = new ParallelBindingContext(this, localSim, behaviors); Entities.DependencyInjection.DI.Resolve(simulation, this, behaviors, context); // Run the simulation localSim.Run(Parameters.Entities); // Allow the behaviors to fetch the behaviors if they want foreach (var behavior in behaviors) { if (behavior is IParallelBehavior parallelBehavior) { parallelBehavior.FetchBehaviors(context); } } } simulation.EntityBehaviors.Add(behaviors); }
/// <summary>Initialize session and base classes.</summary> /// <param name="session">The session.</param> /// <param name="delays">The delays.</param> protected AbstractTssController(TSession session, uint[] delays) : base(session) { Tss = new TSS(delays); _simulation = new TssSimulationWrapper(this); TargetSpeed = AdjustedSpeed = 1.0f; }
public string[] PotentialVariableParameterPathsFor(ISimulation simulation) { var sensitivityAnalysis = new SensitivityAnalysis(simulation); var coreSensitivityAnalysis = _sensitivityAnalysisMapper.MapFrom(sensitivityAnalysis); return(coreSensitivityAnalysis.AllSensitivityParameterPaths); }
private void exportToDirectory(ISimulation simulation, string exportDirectory) { var fileName = createFilePathFor(simulation, exportDirectory, Constants.Filter.XML_EXTENSION); var modelCoreSimulation = _simulationToModelCoreSimulationMapper.MapFrom(simulation, shouldCloneModel: false); _simModelExporter.ExportSimModelXml(modelCoreSimulation, fileName); }
private void UpdateSector(ISimulation sim, SessionResult session, EntitySessionResult result, double curPos, double prevPos) { if (session.State != SessionState.Racing) { return; } var track = sim.Session.Track; if (track.SelectedSectors.Count <= 0) { return; } var i = 0; foreach (var location in track.SelectedSectors.OrderBy(s => s.Index).Select(s => s.Location)) { if (curPos <= location || i <= result.CurrentLap.CurrentSector.Index) { i++; continue; } var now = Updater.CurrentTime - (curPos - location) * (curPos - prevPos); var sector = new CompletedSector(result.CurrentLap.CurrentSector, now); result.CurrentLap.SectorsInt.Add(sector); result.CurrentLap.CurrentSector.BeginTime = now; result.CurrentLap.CurrentSector.Index = i; result.CurrentLap.CurrentSector.ReplayPosition = (int)(sim.Telemetry.SessionTime * 60 + Updater.TimeOffset); break; } }
/// <summary> /// Initializes a new instance of the <see cref="CurrentSwitchBindingContext"/> class. /// </summary> /// <param name="component">The component that creates the behavior.</param> /// <param name="simulation">The simulation for which the behavior is created.</param> /// <param name="behaviors">The created behaviors.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="component"/>, <paramref name="simulation"/> or <paramref name="behaviors"/> is <c>null</c>.</exception> public CurrentSwitchBindingContext(ICurrentControllingComponent component, ISimulation simulation, IBehaviorContainer behaviors) : base(component, simulation, behaviors) { var branch = ControlBehaviors.GetValue <IBranchedBehavior <double> >().Branch; ControlValue = () => branch.Value; }
/// <inheritdoc/> public override void CreateBehaviors(ISimulation simulation) { var behaviors = new BehaviorContainer(Name); if (Parameters.Definition != null && Parameters.Definition.Entities.Count > 0) { // Create our local simulation and binding context to allow our behaviors to do stuff var localSim = new SubcircuitSimulation(Name, simulation, Parameters.Definition, NodeMap); var context = new SubcircuitBindingContext(this, localSim, behaviors); Entities.DependencyInjection.DI.Resolve(simulation, this, behaviors, context); // Run the simulation localSim.Run(Parameters.Definition.Entities); // Allow the behaviors to fetch the behaviors if they want foreach (var behavior in behaviors) { if (behavior is ISubcircuitBehavior subcktBehavior) { subcktBehavior.FetchBehaviors(context); } } } simulation.EntityBehaviors.Add(behaviors); }
private string displayPathAsStringFor(ISimulation simulation, DataColumn column, bool addSimulationName, Action <PathElements> pathElementAdjustments = null) { var pathElements = DisplayPathFor(simulation, column); pathElementAdjustments?.Invoke(pathElements); return(DisplayPathAsStringFrom(pathElements, DefaultPathElementsToUse(addSimulationName, pathElements))); }
protected override void Context() { base.Context(); _sensitivityAnalysis = new SensitivityAnalysis(); _oldSimulation = A.Fake <ISimulation>(); _newSimulation = A.Fake <ISimulation>(); }
protected override void Context() { base.Context(); _simulation = A.Fake <ISimulation>(); var rootContainer = new Container(); _simulation.Model.Root = rootContainer; _constantParameter = DomainHelperForSpecs.ConstantParameterWithValue(10).WithName("ConstantParameter"); _formulaParameter = new Parameter().WithFormula(new ExplicitFormula("1+2")).WithName("FormulaParameter"); _formulaFixedParameter = new Parameter().WithFormula(new ExplicitFormula("1+2")).WithName("FormulaFixedParameter"); _formulaFixedParameter.Value = 10; rootContainer.Add(_constantParameter); rootContainer.Add(_formulaParameter); rootContainer.Add(_formulaFixedParameter); _constantParameterSelection = new ParameterSelection(_simulation, _constantParameter.Name); _formulaParameterSelection = new ParameterSelection(_simulation, _formulaParameter.Name); _formulaFixedParameterSelection = new ParameterSelection(_simulation, _formulaFixedParameter.Name); A.CallTo(() => _simulationParametersPresenter.AllParameters).Returns(new [] { _constantParameterSelection, _formulaParameterSelection, _formulaFixedParameterSelection }); A.CallTo(() => _sensitivityAnalysisParametersPresenter.AddParameters(A <IReadOnlyList <ParameterSelection> > ._)) .Invokes(x => _addedParameters = x.GetArgument <IReadOnlyList <ParameterSelection> >(0)); }
private void InitializeSimulation(SimulationStartParameters simulationStartParameters) { List <IActor> actors; _simulationFileName = string.Empty; // destroy the old simulation or it will keep running with unintended consque this.ClearSimulation(); _simulation = new LangtonsAntSimulation(this); _simulation.Speed = simulationStartParameters.Delay; actors = new List <IActor>(); for (int i = 0; i < simulationStartParameters.InitialActors; i++) { actors.Add(new Ant()); } _simulation.Actors = actors.ToArray(); this.InitializeSimulation(_simulation); _simulation.Start(); if (simulationStartParameters.StartPaused) { _simulation.Pause(); } }
/// <summary> /// Initializes a new instance of the <see cref="ParallelSimulation"/> class. /// </summary> /// <param name="parent">The parent simulation.</param> /// <param name="parameters">The parallel component parameters.</param> public ParallelSimulation(ISimulation parent, IParameterSetCollection parameters) : base(parent, new BehaviorContainerCollection(parent?.EntityBehaviors.Comparer), new InheritedTypeSet <ISimulationState>()) { LocalParameters = parameters.ThrowIfNull(nameof(parameters)); }
protected override void Context() { base.Context(); _cache1 = _runMode.CalculationMethodCacheFor("compound1"); _cache2 = _runMode.CalculationMethodCacheFor("compound2"); _cache1.AddCalculationMethod(new CalculationMethod { Category = "Category1", Name = "method1" }); _cache1.AddCalculationMethod(new CalculationMethod { Category = "Category1", Name = "method2" }); _cache2.AddCalculationMethod(new CalculationMethod { Category = "Category1", Name = "method1" }); _cache2.AddCalculationMethod(new CalculationMethod { Category = "Category1", Name = "method2" }); _cache2.AddCalculationMethod(new CalculationMethod { Category = "Category2", Name = "method3" }); _cache2.AddCalculationMethod(new CalculationMethod { Category = "Category2", Name = "method4" }); _cache2.AddCalculationMethod(new CalculationMethod { Category = "Category2", Name = "method5" }); _simulation = A.Fake <ISimulation>(); _simulation = A.Fake <ISimulation>(); A.CallTo(() => _simulation.CompoundNames).Returns(new[] { "compound2" }); _parameterIdentification.AddSimulation(_simulation); }
protected override void Context() { sut = new CategorialRunModeToCategorialRunModeDTOMapper(); _simulation1 = A.Fake <ISimulation>(); A.CallTo(() => _simulation1.CompoundNames).Returns(new[] { "Drug1", "Drug2" }); _simulation2 = A.Fake <ISimulation>(); A.CallTo(() => _simulation2.CompoundNames).Returns(new[] { "Drug2", "Drug3" }); _allSimulations = new List <ISimulation> { _simulation1, _simulation2 }; _category1 = new CategoryDTO().WithName("Category1"); _category2 = new CategoryDTO().WithName("Category2"); _cm1 = new CalculationMethod { Category = _category1.Name }.WithName("CM1"); _cm2 = new CalculationMethod { Category = _category1.Name }.WithName("CM2"); _cm3 = new CalculationMethod { Category = _category2.Name }.WithName("CM3"); _category1.Methods = new[] { _cm1, _cm2 }; _category2.Methods = new[] { _cm3 }; _allCategories = new[] { _category1, _category2 }; _runMode = new CategorialParameterIdentificationRunMode(); }
public PKCalculationOptions CreateFor(ISimulation simulation, string moleculeName) { var options = new PKCalculationOptions(); var endTime = simulation.EndTime ?? 0; var allApplicationParameters = AllApplicationParametersOrderedByStartTimeFor(simulation, moleculeName); // all application start times starting before the end of the simulation var applicationStartTimes = allApplicationParameters.Select(x => x.StartTime.Value).ToFloatArray(); options.FirstDosingStartValue = applicationStartTimes.FirstOrDefault(); // single dosing if (applicationStartTimes.Length <= 1) { options.FirstDosingEndValue = endTime.ToFloat(); options.InfusionTime = allApplicationParameters.FirstOrDefault()?.InfusionTime?.Value; } else { // 1 because we want the start time of the second application options.FirstDosingEndValue = applicationStartTimes[1]; options.LastMinusOneDosingStartValue = applicationStartTimes[applicationStartTimes.Length - 2]; options.LastDosingStartValue = applicationStartTimes[applicationStartTimes.Length - 1]; options.LastDosingEndValue = endTime.ToFloat(); } // Once all dosing are defined, update applied dose UpdateAppliedDose(simulation, moleculeName, options, allApplicationParameters); return(options); }
public Recorder(ISimulation hostsimulator, RecordType recordtype, string recordfile) { this.hostsimulator = hostsimulator; this.recordtype = recordtype; this.recordfile = recordfile; potentialfile = spikefile = null; potentialwriter = spikewriter = null; }
/// <summary> /// Draws the simualation with the specified colors. /// </summary> /// <param name="g">The graphics context.</param> /// <param name="s">The simulation to draw.</param> public void Draw(Graphics g, ISimulation s) { g.SmoothingMode = SmoothingMode.AntiAlias; DrawPitch(g, s); DrawTeams(g, s); DrawBall(g, s); }
private void DrawPitch(Graphics g, ISimulation s) { var w = s.PitchBounds.Width; g.DrawEllipse(_linePen, -w / 10, -w / 10, w / 5, w / 5); g.DrawRectangle(_linePen, s.PitchBounds); g.DrawRectangle(_linePen, s.Teams[0].GoalBounds); g.DrawRectangle(_linePen, s.Teams[1].GoalBounds); }
/// <summary> /// </summary> /// <param name="player"></param> /// <param name="team"></param> /// <param name="otherTeam"></param> /// <param name="simulation"></param> /// <param name="passingLaneWidth"></param> /// <returns></returns> public static IEnumerable<IPointMass> GetOpenPlayers( PointMass player, ITeam team, ITeam otherTeam, ISimulation simulation, float passingLaneWidth) => from p in team.Players where p != player && IsPlayerOpenForPass(player, p, otherTeam.Players, passingLaneWidth) select p;
/// <summary> /// Executes the team strategy. /// </summary> /// <param name="simulation">The simulation in which the is taking part.</param> /// <returns>The kick.</returns> public Kick ExecuteStrategy(ISimulation simulation) { Contract.Requires<ArgumentNullException>(simulation != null); Contract.Requires<ArgumentException>(Contract.Exists(simulation.Teams, t => t == this)); var kick = _strategy.Execute(simulation, this); if (kick.Player == null || IsKickValid(kick.Player, simulation)) return kick; throw new InvalidOperationException("Invalid kick."); }
public ThreadSimulationProxy(ISimulation simulation) { this.simulation = simulation; //currentSimulationStep = new SimulationStep(); physicsWorker = new PhysicsWorker { Simulation = this, /*SimulationStepQueue = simulationStepQueue, SimulationQueueNotEmpty = simulationQueueNotEmpty */ }; physicsThread = new Thread(physicsWorker.Run) { IsBackground = true }; physicsThread.Start(); }
public SpeciesDetails(WebCrittersForm parent, ISimulation simulation, ISpecies species) { if (parent == null) throw new ArgumentNullException("parent"); if (simulation == null) throw new ArgumentNullException("simulation"); if (species == null) throw new ArgumentNullException("species"); ParentForm = parent; CurrentSpecies = species; Simulation = simulation; InitializeComponent(); UpdateSpeciesDetails(); }
public override Kick Execute(ISimulation simulation) { var ballChaser = FootballStrategies.ClosestPlayerToPoint(this.Players, simulation.Ball, 0); var kick = Kick.None; foreach (var player in Players) { if (player == ballChaser) { //messages[player] = "Chaser"; var playersExceptSelf = Players.ToList(); playersExceptSelf.Remove(player); player.Force = SteeringStrategies.Pursue(player, simulation.Ball, 1); if ((player.Position - simulation.Ball.Position).Length() < player.Radius + simulation.Ball.Radius) { var isLeftTeam = this.GoalBounds.Left > 0 ? true : false; PointMass[] arr = new PointMass[7]; playersExceptSelf.CopyTo(arr, 0); arr[4] = new PointMass(1, 1, 1, 1, new Vector2(isLeftTeam ? this.GoalBounds.Left : this.GoalBounds.Right, this.GoalBounds.Top + (0.2f) * this.GoalBounds.Height), Vector2.Zero); arr[5] = new PointMass(1, 1, 1, 1, new Vector2(isLeftTeam ? this.GoalBounds.Left : this.GoalBounds.Right, this.GoalBounds.Top + (0.5f) * this.GoalBounds.Height), Vector2.Zero); arr[6] = new PointMass(1, 1, 1, 1, new Vector2(isLeftTeam ? this.GoalBounds.Left : this.GoalBounds.Right, this.GoalBounds.Top + (0.8f) * this.GoalBounds.Height), Vector2.Zero); arr[4].id = "GT"; arr[5].id = "GM"; arr[6].id = "GB"; ReadOnlyCollection<PointMass> roc = new ReadOnlyCollection<PointMass>(arr); Vector2 middleOfGoal = new Vector2(isLeftTeam ? this.GoalBounds.Left : this.GoalBounds.Right, this.GoalBounds.Top - (0.5f) * this.GoalBounds.Height); IPointMass kickTarget = ClosestPlayerToPoint(roc, player, 1, middleOfGoal); messages[player] = "Chaser T: " + kickTarget.id; k = kick = FootballStrategies.PassToPlayer(player, kickTarget, simulation.Ball); } else k = kick = Kick.None; } else { messages[player] = isOutsideOfField(player, simulation.PitchBounds) ? "Outside" : "inside"; var allPlayers = simulation.Teams[0].Players.Concat(simulation.Teams[1].Players); if (isOutsideOfField(player, simulation.PitchBounds)) player.Force = SteeringStrategies.Seek(player, Vector2.Zero, player.MaxSpeed); else FootballStrategies.SpreadOut(player, allPlayers, simulation.PitchBounds, 150, 100); } } return kick; }
public Species(ISimulation simulation, IAgent exemplar, params UniqueIdentifier[] derivedFromSpeciesIds) { if (simulation == null) throw new ArgumentNullException("simulation"); if (exemplar == null) throw new ArgumentNullException("exemplar"); this.Simulation = simulation; this.firstSeen = simulation.CurrentGeneration; this.ResourcesFromResourceNodes = 0; this.ResourcesFromAgents = 0; this.Population = 0; this.id = CreateUniqueIdentifier(exemplar); this.derivedFromSpeciesIds.AddRange(derivedFromSpeciesIds); this.exemplar = exemplar.DeepCopy(); }
public GridLocation(int x, int y, ISimulation simulation, List<IResourceNode> resourceAllocation, int upkeep, int capacity) : base(simulation) { if (resourceAllocation == null) throw new ArgumentNullException("resourceAllocation"); if (x < 0) throw new ArgumentOutOfRangeException("x", x, "x must be zero or greater"); if (y < 0) throw new ArgumentOutOfRangeException("y", y, "y must be zero or greater"); if (upkeep < 0) throw new ArgumentOutOfRangeException("upkeep", upkeep, "upkeep must be zero or greater"); if (capacity < 0) throw new ArgumentOutOfRangeException("capacity", upkeep, "capacity must be zero or greater"); Connections = new List<ILocation>(); Agents = new List<IAgent>(); CurrentResources = new List<IResourceNode>(); X = x; Y = y; UpkeepCost = upkeep; ResourceCapacity = capacity; ResourceAllocation = resourceAllocation; }
protected LocationBase(ISimulation simulation) { if (simulation == null) throw new ArgumentNullException("simulation"); this.Simulation = simulation; }
public void AddSimulation(ISimulation simulation) { model.AddSimulation(simulation); }
/// <summary> /// Draws debugging information. /// </summary> /// <param name="simulation">The simulation in which the team is taking part.</param> /// <param name="g">The drawing surface.</param> public virtual void DrawDebugInfo(ISimulation simulation, Graphics g) { }
public Personnage(ISimulation simulation, string nom) { Nom = nom; simulation.Attach<TickEvent>(Tick); this.simulation = simulation; }
protected Program(IContainer container, ISimulation simulation) { _container = container; _simulation = simulation; _application = new Application(); }
private void DrawTeams(Graphics g, ISimulation s) { var pe = _teamPens.GetEnumerator(); var be = _teamBrushes.GetEnumerator(); foreach (var t in s.Teams) { pe.MoveNext(); be.MoveNext(); t.Players.ForEach(p => { DrawPointMass(p, pe.Current, be.Current, g); DrawDebugInfo(p, be.Current, _font, g); }); ((Team)t).DrawDebugInfo(s, g); } }
public static void EndRunningComposition() { _runningComposition = null; }
public ViewEventArgs(ISimulation simulation) { this.Simulation = simulation; }
/// <summary> /// Executes the team strategy. /// </summary> /// <param name="simulation">The simulation in which the team is taking part.</param> /// <returns>The kick.</returns> public abstract Kick Execute(ISimulation simulation);
private void DrawBall(Graphics g, ISimulation s) { g.FillCircle(_ballBrush, s.Ball.Position, s.Ball.Radius); DrawDebugInfo(s.Ball, _ballBrush, _font, g); }
public override void DrawDebugInfo(ISimulation simulation, Graphics g) { //g.DrawLine(Pens.GhostWhite, simulation.Ball.Position, simulation.Ball.Position + simulation.Ball.Velocity); foreach (var p in Players) { //g.DrawLine(Pens.Orange, p.Position, p.Position + 3*p.Velocity); //g.DrawLine(Pens.Purple, p.Position, p.Position + 3*p.Acceleration); if (k.Force != Vector2.Zero && messages[p] == "Chaser") { //g.DrawLine(Pens.Pink, p.Position, p.Position + 3 * k.Force); var playersExceptSelf = Players.ToList(); playersExceptSelf.Remove(p); var target = FootballStrategies.ClosestPlayerToPoint(playersExceptSelf, p, 100); var desired = target.Position - p.Position; //g.DrawLine(Pens.Gold, p.Position, p.Position + 10 * desired); //g.DrawLine(Pens.Fuchsia, simulation.Ball.Position, simulation.Ball.Position + simulation.Ball.Velocity.Projection(desired)); //g.DrawLine(Pens.Brown, simulation.Ball.Position, simulation.Ball.Position + 10 * simulation.Ball.Velocity.Rejection(desired)); } string message; if (messages.TryGetValue(p, out message)) g.DrawString(p.id + ": " + message, SystemFonts.DefaultFont, Brushes.Black, p.Position.X + 10, p.Position.Y + 10); } }
public override Kick Execute(ISimulation simulation) { return Kick.None; }
private bool IsKickValid(IPointMass player, ISimulation simulation) => Players.Any(p => p == player) && (player.Position - simulation.Ball.Position).Length() < player.Radius + simulation.Ball.Radius;
public void AddSimulation(ISimulation simulation) { this.simulations.Add(simulation); this.Changed.Invoke(this, new ModelEventArgs(simulations)); }
public override IFabriquePersonnage CreerFabriquePersonnage(ISimulation simulation) => new FabriquePersonnageNatation(simulation);
public FabriquePersonnageNatation(ISimulation simulation) : base(simulation) { }
public virtual IFabriqueAcces CreerFabriqueAcces(ISimulation simulation) => new FabriqueConcreteAcces();
public FabriquePersonnage(ISimulation simulation) { Simulation = simulation; }
public override IFabriqueZone CreerFabriqueZone(ISimulation simulation) => new FabriqueZoneNatation();
public virtual IFabriquePersonnage CreerFabriquePersonnage(ISimulation simulation) => new FabriquePersonnage(simulation);