def reset(self, extraction_vessel): ''' generate empty vessels ''' vessels = [copy.deepcopy(extraction_vessel)] for i in range(self.n_empty_vessels): temp_vessel = vessel.Vessel(label='beaker_{}'.format(i + 1), v_max=self.max_vessel_volume, default_dt=0.05, n_pixels=self.n_vessel_pixels) vessels.append(temp_vessel) # generate oil vessel oil_vessel = vessel.Vessel( label='oil_vessel', v_max=self.oil_volume, n_pixels=self.n_vessel_pixels, settling_switch=False, layer_switch=False, ) oil_vessel_material_dict = {} C6H14 = material.C6H14 oil_vessel_material_dict[C6H14().get_name()] = [C6H14, self.oil_volume] oil_vessel_material_dict, _, _ = util.check_overflow( material_dict=oil_vessel_material_dict, solute_dict={}, v_max=oil_vessel.get_max_volume()) event = ['update material dict', oil_vessel_material_dict] oil_vessel.push_event_to_queue(feedback=[event], dt=0) state = util.generate_state(vessels, max_n_vessel=self.n_total_vessels) return vessels, oil_vessel, state
def step(self, action): self.vessels, self.external_vessels, reward, self.done = self.extraction.perform_action(vessels=self.vessels, oil_vessel=self.external_vessels, action=action) self.state = util.generate_state(self.vessels, max_n_vessel=self.extraction.n_total_vessels) self.n_steps -= 1 if self.n_steps == 0: self.done = True reward = self.extraction.done_reward(self.vessels[2]) return self.state, reward, self.done, {}
def step(self, action): ''' Update the environment by performing an action. Parameters --------------- `action` : `list` A list of two numbers indicating the index of the action to perform and a multiplier to use in completing the action. Returns --------------- `state` : `np.array` A numpy array containing state variables, material concentrations, and spectral data. `reward` : `float` The amount of reward generated in perfoming the action. `done` : `bool` A boolean indicting if all the steps in an episode have been completed. `params` : `dict` A dictionary containing additional parameters or information that may be useful. Raises --------------- None ''' # define the necessary parameters vessels = self.vessels ext_vessels = self.external_vessels done = self.done # perform the inputted action in the extraction module vessels, ext_vessels, reward, done = self.extraction.perform_action( vessels=vessels, external_vessels=ext_vessels, action=action ) # re-define self variables for future use self.vessels = vessels self.external_vessels = ext_vessels self.done = done # determine the state after performing the action self.state = util.generate_state( self.vessels, max_n_vessel=self.extraction.n_total_vessels ) # document the most recent step and determine if future steps are necessary self.n_steps -= 1 if self.n_steps == 0: self.done = True # once all the steps have been completed, calculate the final reward and save any vessels if self.done: # after the last iteration, calculate the amount of target material in each vessel reward = ExtractionReward( vessels=self.vessels, desired_material=self.target_material, initial_target_amount=self.initial_target_amount ).calc_reward() # use the extraction reward class's `validate_vessels` method to output only the # vessels that pass a certain reward threshold; valid_vessels = ExtractionReward( vessels=self.vessels, desired_material=self.target_material, initial_target_amount=self.initial_target_amount ).validate_vessels( purity_threshold=self.min_purity_threshold ) # save each validated vessel as pickle files for i, vessel in enumerate(valid_vessels): self._save_vessel( extract_vessel=vessel, vessel_rootname="extract_vessel_{}".format(i) ) return self.state, reward, self.done, {}
def reset(self, extraction_vessel): # generate empty vessels vessels = [copy.deepcopy(extraction_vessel)] for i in range(self.n_empty_vessels): temp_vessel = vessel.Vessel(label='beaker_{}'.format(i + 1), v_max=self.max_vessel_volume, default_dt=0.05, n_pixels=self.n_vessel_pixels) vessels.append(temp_vessel) # generate solution vessel2 solution_1_vessel = vessel.Vessel( label='solution_1_vessel', v_max=self.solution_volume, n_pixels=self.n_vessel_pixels, settling_switch=False, layer_switch=False, ) solution_2_vessel = vessel.Vessel( label='solution_2_vessel', v_max=self.solution_volume, n_pixels=self.n_vessel_pixels, settling_switch=False, layer_switch=False, ) H2O = material.H2O Na = material.Na Cl = material.Cl Li = material.Li F = material.F solution_1_vessel_material_dict = { H2O().get_name(): [H2O, 30.0], Na().get_name(): [Na, 1.0], Cl().get_name(): [Cl, 1.0] } solution_1_solute_dict = { Na().get_name(): { H2O().get_name(): 1.0 }, Cl().get_name(): { H2O().get_name(): 1.0 }, } solution_2_vessel_material_dict = { H2O().get_name(): [H2O, 30.0], Li().get_name(): [Li, 1.0], F().get_name(): [F, 1.0] } solution_2_solute_dict = { Li().get_name(): { H2O().get_name(): 1.0 }, F().get_name(): { H2O().get_name(): 1.0 }, } solution_1_vessel_material_dict, solution_1_solute_dict, _ = util.check_overflow( material_dict=solution_1_vessel_material_dict, solute_dict=solution_1_solute_dict, v_max=solution_1_vessel.get_max_volume(), ) solution_2_vessel_material_dict, solution_2_solute_dict, _ = util.check_overflow( material_dict=solution_2_vessel_material_dict, solute_dict=solution_2_solute_dict, v_max=solution_2_vessel.get_max_volume(), ) event_s1_m = ['update material dict', solution_1_vessel_material_dict] event_s1_s = ['update solute dict', solution_1_solute_dict] event_s2_m = ['update material dict', solution_2_vessel_material_dict] event_s2_s = ['update solute dict', solution_2_solute_dict] solution_1_vessel.push_event_to_queue(feedback=[event_s1_m], dt=0) solution_1_vessel.push_event_to_queue(feedback=[event_s1_s], dt=0) solution_2_vessel.push_event_to_queue(feedback=[event_s2_m], dt=0) solution_2_vessel.push_event_to_queue(feedback=[event_s2_s], dt=0) return vessels, [solution_1_vessel, solution_2_vessel], util.generate_state( vessels, max_n_vessel=self.n_total_vessels)
def reset(self, extraction_vessel): ''' Method to reset the environment. Parameters --------------- `extraction_vessel` : `vessel` (default=`None`) A vessel object containing state variables, materials, solutes, and spectral data. Returns --------------- `vessels` : `list` A list of all the vessel objects that contain materials and solutes. `external_vessels` : `list` A list of the external vessels, beakers, to be used in the extraction. `state` : `np.array` An array containing state variables, material concentrations, and spectral data. Raises --------------- None ''' # delete the extraction vessel's solute_dict and copy it into a list of vessels solute_dict = extraction_vessel._solute_dict extraction_vessel._solute_dict = {} vessels = [copy.deepcopy(extraction_vessel)] # create all the necessary beakers and add them to the list for i in range(self.n_empty_vessels): temp_vessel = vessel.Vessel(label='beaker_{}'.format(i + 1), v_max=self.max_vessel_volume, default_dt=0.05, n_pixels=self.n_vessel_pixels) vessels.append(temp_vessel) # generate a list of external vessels to contain solutes external_vessels = [] # generate a vessel to contain the main solute solute_vessel = vessel.Vessel( label='solute_vessel0', v_max=self.solute_volume, n_pixels=self.n_vessel_pixels, settling_switch=False, layer_switch=False, ) # create the material dictionary for the solute vessel solute_material_dict = {} solute_class = convert_to_class(materials=[self.solute])[0] solute_material_dict[self.solute] = [solute_class, self.solute_volume] # check for overflow solute_material_dict, _, _ = util.check_overflow( material_dict=solute_material_dict, solute_dict={}, v_max=solute_vessel.get_max_volume()) # instruct the vessel to update its material dictionary event = ['update material dict', solute_material_dict] solute_vessel.push_event_to_queue(feedback=[event], dt=0) # add the main solute vessel to the list of external vessels external_vessels.append(solute_vessel) # generate vessels for each solute in the extraction vessel for solute_name in solute_dict: # generate an empty vessel to be filled with a single solute solute_vessel = vessel.Vessel(label='solute_vessel{}'.format( len(external_vessels)), v_max=extraction_vessel.v_max, n_pixels=self.n_vessel_pixels, settling_switch=False, layer_switch=False) solute_material_dict = {} solute_material_dict[solute_name] = solute_dict[solute_name] # check for overflow solute_material_dict, _, _ = util.check_overflow( material_dict=solute_material_dict, solute_dict={}, v_max=solute_vessel.get_max_volume()) # instruct the vessel to update its material dictionary event = ['update material dict', solute_material_dict] solute_vessel.push_event_to_queue(feedback=[event], dt=0) # add this solute vessel to the list of external vessels external_vessels.append(solute_vessel) # generate the state state = util.generate_state(vessel_list=vessels, max_n_vessel=self.n_total_vessels) return vessels, external_vessels, state