def test_read_from_directory_analysis_built(self):
     """Tests that a DrillSim that is read from a directory that with a simulation that has been built sets the correct value for DrillSim.built.
     
     """
     drill_sim = DrillSim.read_from_directory(
         TEST_EXISTING_DRILLSIM_DIRECTORY)
     self.assertTrue(drill_sim.built)
    def test_modify_solver_settings_before_build(self):
        # Load the drill sim
        drill_sim = DrillSim.read_from_directory(
            TEST_EXISTING_UNBUILT_DRILLSIM_DIRECTORY)

        # Backup the drill sim's acf file and ssf files
        shutil.copyfile(drill_sim.solver_settings.filename,
                        drill_sim.solver_settings.filename + '.tmp')

        # Read in the new solver settings
        new_solver_settings = adripy.DrillSolverSettings.read_from_file(
            TEST_SOLVER_SETTINGS_FILE)

        # Update the drill sim with the new solver setings
        drill_sim.modify_solver_settings(new_solver_settings)

        failures = check_file_contents(
            drill_sim.solver_settings.filename,
            EXPECTED_DRILLSIM_SSF_TEXT_AFTER_SSF_CHANGE)

        # Replace files
        os.remove(drill_sim.solver_settings.filename)
        os.rename(drill_sim.solver_settings.filename + '.tmp',
                  drill_sim.solver_settings.filename)

        # Assert no failures
        self.assertListEqual(failures, [])
    def test_read_from_directory_analysis_name(self):
        """Tests that a DrillSim that is read from a directory has the correct analysis name.

        """
        drill_sim = DrillSim.read_from_directory(
            TEST_EXISTING_DRILLSIM_DIRECTORY)
        self.assertEqual(drill_sim.analysis_name,
                         TEST_EXISTING_DRILLSIM_ANALYSIS_NAME)
    def setUp(self):
        # Create a test config file containing the test database
        adripy.create_cfg_file(TEST_CONFIG_FILENAME,
                               [TEST_DATABASE_PATH, TEST_NEW_DATABASE_PATH])

        # Create the res and msg files
        for file in glob.glob(
                os.path.join(TEST_EXISTING_DRILLSIM_DIRECTORY, '*.cached')):
            shutil.copyfile(file, file.replace('.cached', ''))

        self.drill_sim = DrillSim.read_from_directory(
            TEST_EXISTING_DRILLSIM_DIRECTORY)
        if not self.drill_sim.solved:
            self.drill_sim.run()
    def test_read_from_file_then_build(self):
        """Tests that a DrillSim can be built after being read in from a directory.

        """
        # Read in the DrillSim
        drill_sim = DrillSim.read_from_directory(
            TEST_EXISTING_UNBUILT_DRILLSIM_DIRECTORY)

        # Build the drill_sim
        drill_sim.build()

        # Assert that the acf file exists
        self.assertTrue(
            os.path.exists(
                os.path.join(drill_sim.directory, drill_sim.acf_filename)))
    def test_read_shrink_read(self):
        """Tests that drill_sim results can be read-and-shrunk, then read again.

        """
        # Read and shrink
        self.drill_sim.read_results(t_min=80,
                                    t_max=99,
                                    shrink_results_file=True)
        old_reqs = [k for k in self.drill_sim.results]

        new_drill_sim = DrillSim.read_from_directory(
            TEST_EXISTING_DRILLSIM_DIRECTORY)
        new_drill_sim.read_results(t_min=80, t_max=99)

        new_reqs = [k for k in new_drill_sim.results]

        self.assertEqual(sorted(old_reqs), sorted(new_reqs))
    def setUp(self):
        # Create a test config file containing the test database
        adripy.create_cfg_file(TEST_CONFIG_FILENAME,
                               [TEST_DATABASE_PATH, TEST_NEW_DATABASE_PATH])

        # Create a DrillTool object representing a stabilizer
        self.pdc_bit = adripy.DrillTool(TEST_PDC_FILE)

        # Create a DrillTool object representing a stabilizer
        self.stabilizer = adripy.DrillTool(TEST_STABILIZER_FILE)

        # Create a DrillTool object representing a drill pipe
        self.drill_pipe = adripy.DrillTool(TEST_DRILLPIPE_FILE)

        # Create a DrillTool object representing EUS
        self.eus = adripy.DrillTool(TEST_EUS_FILE)

        # Create a DrillTool object representing a top drive
        self.top_drive = adripy.DrillTool(TEST_TOP_DRIVE_FILE)

        # Create a DrillString object
        self.drill_string = adripy.DrillString(TEST_STRING_NAME,
                                               TEST_EXISTING_HOLE_FILE,
                                               TEST_EVENT_FILE)

        # Add the DrillTool objects to the DrillString object
        self.drill_string.add_tool(self.pdc_bit, measure='yes')
        self.drill_string.add_tool(self.stabilizer, measure='yes')
        self.drill_string.add_tool(self.drill_pipe,
                                   joints=20,
                                   group_name='Upper_DP_Group')
        self.drill_string.add_tool(self.eus,
                                   joints=20,
                                   group_name='equivalent_pipe',
                                   equivalent=True)
        self.drill_string.add_tool(self.top_drive)

        # Create an event object
        self.event = adripy.DrillEvent(TEST_EVENT_NAME, 2000, 3)
        self.event.add_simulation_step(10)
        self.event.add_simulation_step(100)
        self.event.add_ramp('FLOW_RATE', 0, 15, 500)
        self.event.add_ramp('ROTARY_RPM', 15, 15, 60)
        self.event.add_ramp('WOB', 30, 15, 50000)
        self.event.add_ramp('ROP', 30, 15, 100)

        # Create a solver settings object
        self.solver_settings = adripy.DrillSolverSettings(
            TEST_SOLVER_SETTINGS_NAME)

        # If the "existing" drill sims don't exit, create them
        for directory in [
                TEST_EXISTING_DRILLSIM_DIRECTORY,
                TEST_EXISTING_UNBUILT_DRILLSIM_DIRECTORY
        ]:
            if not os.path.exists(directory):
                create_existing_drillsim(directory)

        drill_sim = DrillSim.read_from_directory(
            TEST_EXISTING_DRILLSIM_DIRECTORY)
        if drill_sim.built is False:
            drill_sim.build()