static private string NameImageFile() { ExperimentSettings _expInstance = ExperimentSettings.GetInstance(); string imageFileName = _expInstance.FileName + "_" + _expInstance.MazeSettings.TrialName + _expInstance.TrialTracker[_expInstance.MazeSettings.TrialName].ToString() + "_"; if (ExperimentSettings.IsAP() || ExperimentSettings.IsSPT() || ExperimentSettings.IsTP()) { if (_expInstance.MazeSettings.Arrows) { imageFileName += "Arrows_"; } } if (ExperimentSettings.IsCM()) { imageFileName += "Start" + _expInstance.MazeSettings.StartLocationCM + "-"; if (!string.IsNullOrEmpty(_expInstance.MazeSettings.LandmarkGoalCM)) { imageFileName += "Landmark" + _expInstance.MazeSettings.LandmarkGoalCM; } } imageFileName += "_path.png"; return(imageFileName); }
public NeatTrainer(ExperimentSettings experimentSettings, NeatEvolutionAlgorithmParameters evolutionAlgorithmParameters, TrainingGameSettings gameSettings) { var neuromonPhenomeEvaluator = new NeuromonEvaluator(gameSettings, experimentSettings); var neatGenomeParameters = new NeatGenomeParameters(); _neuromonExperiment = new NeuromonExperiment(experimentSettings, evolutionAlgorithmParameters, neuromonPhenomeEvaluator, neatGenomeParameters); _genomeIo = new GenomeIo(_neuromonExperiment); _genomeFactory = _neuromonExperiment.CreateGenomeFactory(); if (experimentSettings.LoadExistingPopulation) { _genomePopulation = _genomeIo.Read(experimentSettings.ExistingPopulationFilePath); } else { // Randomly generate a new population _genomePopulation = _genomeFactory.CreateGenomeList(experimentSettings.PopulationSize, 0); } _genomeIo.CacheChampion(_genomePopulation.OrderByDescending(g => g.EvaluationInfo.Fitness).First()); _fitnessStagnationDetector = new FitnessStagnationDetector(experimentSettings.StagnationDetectionTriggerValue); _desiredFitness = experimentSettings.DesiredFitness; _previousGeneration = 0; _overallBestFitness = 0.0; }
public static void NameAndCountTrial() { _instance.MazeSettings.TrialName = _instance.MazeSettings.MazeName.ToString(); if (ExperimentSettings.IsStudy() && !ExperimentSettings.IsPractice()) { _instance.MazeSettings.TrialName += "_LearnT"; } else if (!ExperimentSettings.IsStudy() && !ExperimentSettings.IsPractice()) { if (!_instance.MazeSettings.Reverse) { _instance.MazeSettings.TrialName += "_FWDT"; } else { _instance.MazeSettings.TrialName += "_REVT"; } } if (_instance.TrialTracker.ContainsKey(_instance.MazeSettings.TrialName)) { _instance.TrialTracker[_instance.MazeSettings.TrialName] += 1; } else { _instance.TrialTracker[_instance.MazeSettings.TrialName] = 1; } }
void Awake() { if (_instance != null) { Debug.Log("Instance already exists!"); Destroy(transform.gameObject); return; } _instance = this; checkpointButton.gameObject.SetActive(true); resumeFromCheckpointButton.gameObject.SetActive(false); // DoMicTest (); // if(Application.loadedLevel==0) // InitMainMenuLabels (); // CheckGamifiedStatus (); // if (SceneManager.GetActiveScene ().name == "EndMenu") { // AttachSceneController (); ChangeFirstEnvironment(); // ChangeReevalType (); reevalType = ReevalType.Transition; InitMainMenuLabels(); SetConnectionMethod(); SetSessionDay(); SetControlDevice(); SetControlToggle(); // reevalType = ReevalType.Reward; // } }
public ExperimentObserver(StorageCache cache, ExperimentSettings expSettings, BiomeFilter filter, ScanInterface scanMapInterface, string expid, ModuleScienceExperiment exp = null) { settings = expSettings; biomeFilter = filter; requireControllable = true; if (exp != null) { rerunnable = exp.rerunnable; resettable = exp.resettable; } if (scanMapInterface == null) { scanMapInterface = new DefaultScanInterface(); } scanInterface = scanMapInterface; experiment = ResearchAndDevelopment.GetExperiment(expid); if (experiment == null) { Log.Error("Failed to get experiment '{0}'", expid); } storage = cache; Rescan(); }
/////////////////////////////////////////////////////////////////////////////// // Construction and Initializing methods // /////////////////////////////////////////////////////////////////////////////// #region CONSTRUCTION /// <summary> /// Initializes a new instance of the Document class. /// </summary> public Document() { activeDocument = this; this.isModified = false; this.experimentSettings = new ExperimentSettings(); this.selectionState = new SelectionsState(); }
public static Experiment CreateExperimentGO(string expName, ExperimentSettings settings = null) { var expGO = new GameObject(); expGO.transform.name = expName; expGO.transform.parent = ExperimentManager.Instance.transform; var experimentClass = TypeHelper.GetTypeByName(expName); if (experimentClass == null) { Debug.Log("Experiment of name " + expName + "does not exist"); return(null); } var exp = expGO.AddComponent(experimentClass) as Experiment; //exp.Settings if (exp != null) { exp.AddSettings(settings); //this is here so that logs are created properly exp.Name = expName; return(exp); } return(null); }
public async Task <ExperimentSettings> CreateAsync(ExperimentSettings entity) { VPLContext.ExperimentSettings.Add(entity); await VPLContext.SaveChangesAsync(); return(entity); }
void OpenSubmenu() { // Cursor is disabled coming out of maze scenes Cursor.visible = true; Cursor.lockState = CursorLockMode.None; // QUESTION: Could this be simplified? Still have to line up the right menu w/ the experiment type selected. FirstPanel.SetActive(false); if (ExperimentSettings.IsAP()) { APPanel.SetActive(true); } else if (ExperimentSettings.IsSPT()) { SPTPanel.SetActive(true); } else if (ExperimentSettings.IsTP()) { TPPanel.SetActive(true); } else if (ExperimentSettings.IsCM()) { CMPanel.SetActive(true); } }
public void OnTriggerEnter(Collider other) { Debug.Log("MazeEnd() being called due to maze completion"); ExperimentSettings _instance = ExperimentSettings.GetInstance(); _instance.MazeSettings.ReachedEnd = true; MazeController.MazeEnd(); }
public static ExperimentSettings GetInstance() { if (_instance == null) { _instance = new ExperimentSettings(); } return(_instance); }
public void SetDir(ExperimentSettings _expInstance) { string currentDir = System.IO.Directory.GetCurrentDirectory(); string newDir = "reapg" + _expInstance.ParticipantID + "_" + _expInstance.ExperimentType + "_Sess" + _expInstance.Session.ToString(); _expInstance.FileDir = currentDir + "\\" + newDir + "_" + DateTime.Now.ToString("ddHHmm"); System.IO.Directory.CreateDirectory(_expInstance.FileDir); _expInstance.FileName = _expInstance.FileDir + "\\" + newDir; }
public async Task <IActionResult> PutExperimentSettings([FromBody] ExperimentSettings experimentSettings) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } await ExperimentService.UpdateSettingsAsync(experimentSettings); return(NoContent()); }
static private List <string> GetExperimentHeader() { List <string> experimentHeader = new List <string>(); ExperimentSettings _expInstance = ExperimentSettings.GetInstance(); experimentHeader.Add("Participant ID: " + _expInstance.ParticipantID); experimentHeader.Add("Experimenter Initials: " + _expInstance.ExperimenterInitials); experimentHeader.Add("Date: " + _expInstance.Date); experimentHeader.Add("Experiment Type: " + _expInstance.ExperimentType); return(experimentHeader); }
private int AudibleSelectionGrid(int currentValue, ref ExperimentSettings settings) { int num = GUILayout.SelectionGrid(currentValue, filterList.ToArray(), 2, GUILayout.ExpandWidth(true)); if (num == currentValue) { return(num); } audio.PlayUI("click1"); settings.Filter = (ExperimentSettings.FilterMethod)num; return(num); }
/// <summary> /// Construct an experiment with the given parameters /// </summary> public ExperimentProvider(ExperimentSettings settings, StimulusClass stimulusClass1, StimulusClass stimulusClass2, IArrayView <ClassificationScheme> classificationSchemes, IEEGDataSource dataSource) { this.Settings = settings; this.StimulusClass1 = stimulusClass1; this.StimulusClass2 = stimulusClass2; this.ClassificationSchemes = classificationSchemes; this.DataSource = dataSource; }
public static ExperimentSettings PopulateExperimentSettings(string expName, string path) { ExperimentSettings settings = null; Type type = ExperimentSettingsType(expName); if (type != null) { settings = ScriptableObject.CreateInstance(type) as ExperimentSettings; settings.DeserialiseSettings(path); } return(settings); }
public ExperimentService( Belsim2020DbContext dbContext, ILogger <ExperimentService> logger, IMapper mapper, ICurrentUserContext userContext, IOptions <ExperimentSettings> settings) { this.dbContext = dbContext; this.logger = logger; this.mapper = mapper; this.userContext = userContext; this.options = settings.Value; }
private void Start() { _expInstance = ExperimentSettings.GetInstance(); _expInstance.MazeSettings = new MazeSettings(); if (!string.IsNullOrEmpty(_expInstance.ExperimenterInitials)) // if this already exists then we're coming out of a maze { OpenSubmenu(); } else { PopulateDropdown(); } }
/// <summary> /// Load experiment settings from settings file given in parameters. /// </summary> /// <param name="filePath">A <see cref="string"/> with the path /// and filename to the settings file.</param> /// <param name="splash">The loading document splash screens background worker, /// needed for interrupting splash when SQL connection fails.</param> /// <returns><strong>True</strong>,if successful, otherwise /// <strong>false</strong>.</returns> public bool LoadSettingsFromFile(string filePath, BackgroundWorker splash) { try { this.experimentSettings = ExperimentSettings.Deserialize(filePath); // If deserialization succeeded update possible copied experiment folders // references. if (this.experimentSettings != null) { string filename = Path.GetFileNameWithoutExtension(filePath); string directory = Path.GetDirectoryName(filePath); // Setup document path and name this.experimentSettings.DocumentPath = directory; // Set path properties of slideshow elements this.experimentSettings.SlideShow.UpdateExperimentPathOfResources( this.experimentSettings.SlideResourcesPath); // Write version information if (!this.experimentSettings.UpdateVersion()) { return(false); } this.experimentSettings.Name = filename; // Check if database file is correct located in the connection string // abort if user aborts. if (!this.experimentSettings.CheckDatabasePath()) { return(false); } return(true); } } catch (WarningException) { // This is the case when the user cancels the upgrading return(false); } catch (Exception ex) { ExceptionMethods.HandleException(ex); } return(false); }
public static void ConfigureExperiment(ushort newWordsSeen, ushort newSessionNumber, IronPython.Runtime.List newWords = null) { wordsSeen = newWordsSeen; session = newSessionNumber; settings = FRExperimentSettings.GetSettingsByName(UnityEPL.GetExperimentName()); bool isEvenNumberSession = newSessionNumber % 2 == 0; bool isTwoParter = settings.isTwoParter; if (words == null) { SetWords(settings.wordListGenerator.GenerateListsAndWriteWordpool(settings.numberOfLists, settings.wordsPerList, settings.isCategoryPool, isTwoParter, isEvenNumberSession, UnityEPL.GetParticipants()[0])); } SaveState(); }
private void OnTriggerEnter(Collider other) { ExperimentSettings _expInstance = ExperimentSettings.GetInstance(); if (_expInstance.MazeSettings.Rotate || _expInstance.MazeSettings.Pause) { Debug.Log(gameObject.transform.position); MazeController.cornerTransform = gameObject.transform; gameObject.SetActive(false); //Debug.Log(gameObject.ToString()); MazeController.onCorner = cornerNum; MazeController.cornerEvent = true; } }
public async Task <IActionResult> PostExperimentSettings([FromBody] ExperimentSettings experimentSettings) { experimentSettings.LogicalName = "experiment_settings"; experimentSettings.CreatedOn = DateTime.Now; experimentSettings.Experiment = await ExperimentRepository.GetByIdAsync(experimentSettings.ExperimentId); if (!ModelState.IsValid) { return(BadRequest(ModelState)); } experimentSettings = await ExperimentService.CreateSettingsAsync(experimentSettings); return(CreatedAtAction("GetExperimentSettings", new { id = experimentSettings.Id }, experimentSettings)); }
public async Task <ExperimentSettings> UpdateSettingsAsync(ExperimentSettings entity) { var newExperimentSettings = await ExperimentSettingsRepository.GetByExperimentAsync(entity.ExperimentId); newExperimentSettings.Axis = entity.Axis; newExperimentSettings.Friction = entity.Friction; newExperimentSettings.Restitution = entity.Restitution; newExperimentSettings.Walls = entity.Walls; newExperimentSettings.Gravity = entity.Gravity; newExperimentSettings.Size = entity.Size; var experimentSettings = await ExperimentSettingsRepository.UpdateAsync(newExperimentSettings); return(experimentSettings); }
/// <summary> /// Save experiment settings to settings file given in parameters. /// </summary> /// <param name="filePath">A <see cref="string"/> with the path /// and filename to the settings file.</param> /// <returns><strong>True</strong>,if successful, otherwise /// <strong>false</strong>.</returns> public bool SaveSettingsToFile(string filePath) { try { if (ExperimentSettings.Serialize(this.experimentSettings, filePath)) { return(true); } } catch (Exception ex) { ExceptionMethods.HandleException(ex); } return(false); }
private void OnStart() { if (MeasurementManager.CurrentExperiment == null) { var settings = new ExperimentSettings( TimeSpan.FromMilliseconds(ExperimentSettings.SamplingIntervalMilliseconds), IsDeltaOnly); MeasurementManager.CreateExperiment(settings); } else { MeasurementManager.CurrentExperiment.Settings.SamplingInterval = TimeSpan.FromMilliseconds(ExperimentSettings.SamplingIntervalMilliseconds); } MeasurementManager.Start(); }
public NeuromonExperiment(ExperimentSettings experimentSettings, NeatEvolutionAlgorithmParameters evolutionAlgorithmParameters, IPhenomeEvaluator<IBlackBox> neuromonPhenomeEvaluator, NeatGenomeParameters genomeParameters) { Name = experimentSettings.ExperimentName; Description = experimentSettings.Description; InputCount = experimentSettings.InputCount; OutputCount = experimentSettings.OutputCount; DefaultPopulationSize = experimentSettings.PopulationSize; _neuromonPhenomeEvaluator = neuromonPhenomeEvaluator; _complexityRegulationStrategy = experimentSettings.ComplexityRegulationStrategy; _complexityThreshold = experimentSettings.ComplexityThreshold; // Removed from .xml configuration. TODO: Possibly make configurable via json config _networkActivationScheme = NetworkActivationScheme.CreateCyclicFixedTimestepsScheme(1); NeatEvolutionAlgorithmParameters = evolutionAlgorithmParameters; NeatGenomeParameters = genomeParameters; }
static private List <string> GetExperimentInfo() { List <string> experimentInfo = new List <string>(); ExperimentSettings _expInstance = ExperimentSettings.GetInstance(); experimentInfo.Add(_expInstance.MazeSettings.TrialName + _expInstance.TrialTracker[_expInstance.MazeSettings.TrialName].ToString()); experimentInfo.Add("Maze: " + _expInstance.MazeSettings.MazeName.ToString()); experimentInfo.Add("Trial Number: " + _expInstance.TrialTracker[_expInstance.MazeSettings.TrialName].ToString()); experimentInfo.Add("Experiment Type: " + _expInstance.ExperimentType); if (ExperimentSettings.IsAP() || ExperimentSettings.IsSPT() || ExperimentSettings.IsTP()) { experimentInfo.Add("Arrows: " + _expInstance.MazeSettings.Arrows.ToString()); } if (ExperimentSettings.IsCM()) { experimentInfo.Add("CM Start Location: " + _expInstance.MazeSettings.StartLocationCM); if (!string.IsNullOrEmpty(_expInstance.MazeSettings.StartLocationCM)) { experimentInfo.Add("CM Landmark:" + _expInstance.MazeSettings.LandmarkGoalCM); } } experimentInfo.Add("Distance: " + totalDistance); experimentInfo.Add("Time: " + totalTime); experimentInfo.Add("Avg. Velocity: " + avgVelocity); if (_expInstance.MazeSettings.ReachedEnd && _expInstance.MazeSettings.MazeName != MazeNameEnum.JP) { experimentInfo.Add("Reached End: " + _expInstance.MazeSettings.ReachedEnd.ToString()); } else if (!_expInstance.MazeSettings.ReachedEnd && _expInstance.MazeSettings.MazeName != MazeNameEnum.JP) { experimentInfo.Add("Reached End: False, manual exit"); } experimentInfo.Add("\r\n"); return(experimentInfo); }
/////////////////////////////////////////////////////////////////////////////// // Public methods // /////////////////////////////////////////////////////////////////////////////// #region PUBLICMETHODS /// <summary> /// Destruction. Clear member fields and close database connections. /// </summary> public void CleanUp() { //SqlConnection connectionString = new SqlConnection(Document.ActiveDocument.ExperimentSettings.ServerConnectionString); //ServerConnection connection = new ServerConnection(connectionString); //Server sqlServer = new Server(connection); try { //// If there are open connections set offline and online to kill all //// active connections, they are not used anymore. //int connections = sqlServer.GetActiveDBConnectionCount(Document.ActiveDocument.ExperimentSettings.Name); //if (connections > 0) //{ // string query = "ALTER DATABASE \"" + Document.ActiveDocument.ExperimentSettings.Name + // "\" SET OFFLINE WITH ROLLBACK IMMEDIATE;"; // Queries.ExecuteSQLCommand(query); // query = "ALTER DATABASE \"" + Document.ActiveDocument.ExperimentSettings.Name + // "\" SET ONLINE;"; // Queries.ExecuteSQLCommand(query); //} // Close database connection if (this.dataSet != null) { this.dataSet.Dispose(); } //// Detach database from user instance //if (sqlServer.Databases.Contains(Document.ActiveDocument.ExperimentSettings.Name)) //{ // sqlServer.DetachDatabase(Document.ActiveDocument.ExperimentSettings.Name, true); //} } catch (Exception ex) { ExceptionMethods.HandleException(ex); } activeDocument = null; this.isModified = false; this.experimentSettings = null; this.selectionState = null; }
void Update() { if (Input.GetKeyDown(KeyCode.E) && !hasEnded) { MazeEnd(); SceneManager.LoadScene(0); } else if (Input.GetKeyDown(KeyCode.E) && hasEnded) { SceneManager.LoadScene(0); } if (Input.GetKeyDown("space") && !hasStarted) { ExperimentSettings.NameAndCountTrial(); if (_expInstance.MazeSettings.MultiIntro) { StartCoroutine(MultiPicIntro()); } else if (_expInstance.MazeSettings.SingleIntro) { StartCoroutine(SinglePicIntro()); } else { StartCoroutine(WaitAndStart()); InvokeRepeating("TrackPathEverySecond", 2.0f, 1.0f); controller.enabled = true; } } // Trial has begun, do the following: if (hasStarted && !hasEnded) { currentPos = subjectInstance.transform.position; totalDistance += Vector3.Distance(currentPos, lastPos); totalTime += Time.deltaTime; lastPos = currentPos; } }
private static void RunExperiment(ExperimentSettings settings) { try { GlobalVariables.Dimensions = settings.Dimensions; GlobalVariables.GrowCondition = new GrowCondition( settings.MaxDecisionTreeHeight, settings.MaxAttributeUsage, settings.MinLeafSize); dataStorage = new DataStorage( settings.LearnFilePath, settings.ValidationFilePath, settings.TestFilePath); LearnDecisionTree(); CalculateStatistics(settings); } catch (Exception e) { Console.WriteLine("Something went wrong."); } }
void Start() { _expInstance = ExperimentSettings.GetInstance(); InitMaze(); totalDistance = 0; totalTime = 0; path = new List <string>(); hasEnded = false; hasStarted = false; picCounter = 0; grabAndFaceForward = false; subjectInstance = GameObject.FindWithTag("Player"); controller = subjectInstance.GetComponent <UnityStandardAssets.Characters.FirstPerson.FirstPersonController>(); controller.enabled = false; lastPos = subjectInstance.transform.position; currentPos = subjectInstance.transform.position; GameObject _goTransform = new GameObject(); cornerTransform = _goTransform.transform; }
public static Settings GetSettings(string experimentID) { Settings settings = GetSettings(); ExperimentSettings expSettings = null; if (experimentID != null) { if (string.IsNullOrWhiteSpace(experimentID)) { throw new ArgumentException("experimentID", "Experiment ID cannot be whitespace."); } if (!s_experimentSettings.TryGetValue(experimentID, out expSettings)) { expSettings = new ExperimentSettings(s_appSettings, experimentID); s_experimentSettings.Add(experimentID, expSettings); } } settings.m_experimentSettings = expSettings; return settings; }
//private void ReadVersion1(XPathNavigator nav) //{ // var iter = nav.SelectSingleNode("/Settings/GlobalLogLevels"); // if (iter == null) // throw new XmlSchemaException("Settings elements does not match the required elements for this version."); // else if (iter.Value != "null") // { // XmlReader pathReader = iter.ReadSubtree(); // pathReader.MoveToContent(); // pathReader.Read(); // XmlSerializer serializer = TraceLab.Core.Serialization.XmlSerializerFactory.GetSerializer(typeof(SerializableDictionary<LogLevel, GlobalLogLevelSetting>), null); // var logLevels = (SerializableDictionary<LogLevel, GlobalLogLevelSetting>)serializer.Deserialize(pathReader); // foreach (KeyValuePair<LogLevel, GlobalLogLevelSetting> pair in logLevels) // { // m_globalLogLevelSettingLookup[pair.Key].IsEnabled = pair.Value.IsEnabled; // m_globalLogLevelSettingLookup[pair.Key].IsLocked = pair.Value.IsLocked; // } // } // iter = nav.SelectSingleNode("/Settings/MainWindowData"); // if (iter == null) // throw new XmlSchemaException("Settings elements does not match the required elements for this version."); // else if (!string.IsNullOrEmpty(iter.Value) && iter.Value != "null") // { // XmlReader pathReader = iter.ReadSubtree(); // //pathReader.MoveToContent(); // //pathReader.Read(); // XmlSerializer serializer = TraceLab.Core.Serialization.XmlSerializerFactory.GetSerializer(typeof(MainWindowData), null); // MainWindowRect = (MainWindowData)serializer.Deserialize(pathReader); // } //} //private void ReadVersion2(XPathNavigator nav) //{ // // Version 1 data hasn't changed. // ReadVersion1(nav); //} private static void ReadVersion3(XPathNavigator nav) { var child = nav.SelectSingleNode("/Settings/ApplicationSettings"); s_appSettings.ReadXml(child); List<ExperimentSettings> settings = new List<ExperimentSettings>(); var nodeIterator = nav.Select("/Settings/ExperimentSettings"); while (nodeIterator.MoveNext()) { ExperimentSettings newSettings = new ExperimentSettings(s_appSettings, null); newSettings.ReadXml(nodeIterator.Current); settings.Add(newSettings); } var nonExpiredSettings = settings.Where((o) => { return (DateTime.Now - o.LastOpened) < s_appSettings.ExperimentSettingsTTL; }); foreach(ExperimentSettings expSetting in nonExpiredSettings) { s_experimentSettings.Add(expSetting.ExperimentID, expSetting); } }