Python Backend.MPICommons类代码示例

    def testConstruction(self):
        """ Test the LatticeTrajectory object can be constructed. """
        # Setup input.
        sites = [[1.0,1.0,2.3],
                 [3.4,4.5,4.3],
                 [3.7,7.5,6.5]]
        name = os.path.abspath(os.path.dirname(__file__))
        name = os.path.join(name, "..", "..")
        name = os.path.join(name, "TestUtilities", "Scratch")
        trajectory_filename = os.path.join(name, "tmp_trajectory_file.py")

        if MPICommons.isMaster():
            self.__files_to_remove.append(trajectory_filename)

        # Construct with default values.
        dt = LatticeTrajectory(trajectory_filename, Config(sites))

        # Check the defaults.
        self.assertAlmostEqual( dt._Trajectory__max_buffer_time,  60*30 )
        self.assertEqual( dt._Trajectory__max_buffer_size, 1024*1024*10 )

        # Construct.
        t = LatticeTrajectory(trajectory_filename,
                              Config(sites),
                              max_buffer_time=100.0,
                              max_buffer_size=100000)

        # Check the stored values.
        self.assertEqual( t._Trajectory__max_buffer_time,  100.0 )
        self.assertEqual( t._Trajectory__max_buffer_size, 100000 )
        self.assertEqual( t._trajectory_filename, trajectory_filename )

        # Open the trajectory file and check that we can read the meta
        # information and sites.
        if MPICommons.isMaster():
            global_dict = {}
            local_dict  = {}
            execfile(trajectory_filename, global_dict, local_dict)

            # Get the version and creation time.
            read_version  = local_dict["version"]
            read_creation = local_dict["creation_time"]

            # Check that they are of corect type.
            self.assertTrue( isinstance(read_version, str) )
            self.assertTrue( isinstance(read_creation, str) )

            # Check the sites.
            read_sites = numpy.array(local_dict["sites"])
            ref_sites  = numpy.array(sites)
            self.assertAlmostEqual( numpy.linalg.norm(read_sites - ref_sites), 0.0, 10 )

            # Check the empty lists.
            read_times = local_dict["times"]
            read_steps = local_dict["steps"]
            read_types = local_dict["types"]
            empty_list = []
            self.assertEqual( read_times, empty_list )
            self.assertEqual( read_steps, empty_list )
            self.assertEqual( read_types, empty_list )

    def __writeHeader(self, configuration):
        """
        Write the header to the file.

        :param configuration: The configuration of the system.
        """
        # Make sure only master writes.
        if MPICommons.isMaster():

            # Open the file and write the meta information.
            with open(self._trajectory_filename, 'w') as trajectory:

                # Version.
                trajectory.write("KMCLib XYZ FORMAT VERSION 2013.10.15\n\n")

                # Cellvectors.
                cell_vectors = configuration.lattice().unitCell().cellVectors()
                trajectory.write("CELL VECTORS\n")
                trajectory.write("a: %15.10e %15.10e %15.10e\n"%(cell_vectors[0][0], cell_vectors[0][1], cell_vectors[0][2]))
                trajectory.write("b: %15.10e %15.10e %15.10e\n"%(cell_vectors[1][0], cell_vectors[1][1], cell_vectors[1][2]))
                trajectory.write("c: %15.10e %15.10e %15.10e\n\n"%(cell_vectors[2][0], cell_vectors[2][1], cell_vectors[2][2]))

                # Repetitions.
                repetitions = configuration.lattice().repetitions()
                trajectory.write("REPETITIONS %i %i %i\n\n"%(repetitions[0], repetitions[1], repetitions[2]))

                # Periodicity.
                periodicity = configuration.lattice().periodic()
                trajectory.write("PERIODICITY %s %s %s\n\n"%(str(periodicity[0]), str(periodicity[1]), str(periodicity[2])))

        # While the other processes wait.
        MPICommons.barrier()

    def testVersion(self):
        """ Test the LatticeTrajectory file version number string. """
        # Setup input.
        sites = [[1.0,1.0,2.3],
                 [3.4,4.5,4.3],
                 [3.7,7.5,6.5]]
        name = os.path.abspath(os.path.dirname(__file__))
        name = os.path.join(name, "..", "..")
        name = os.path.join(name, "TestUtilities", "Scratch")
        trajectory_filename = os.path.join(name, "tmp_trajectory_file.py")

        if MPICommons.isMaster():
            self.__files_to_remove.append(trajectory_filename)

        # Construct.
        t = LatticeTrajectory(trajectory_filename, Config(sites))

        # Open the trajectory file and check that we can read the meta
        # information and sites.
        if MPICommons.isMaster():
            global_dict = {}
            local_dict  = {}
            execfile(trajectory_filename, global_dict, local_dict)

            # Get the version and check.
            read_version  = local_dict["version"]
            ref_version = "2013.1.0"
            self.assertEqual( read_version, ref_version )

    def testPrettyPrint(self):
        """ Test that we can call the pretty print function. """
        # Print to stdout.
        original_sys_stdout = sys.stdout
        try:
            stream_1   = StringIO.StringIO()
            sys.stdout = stream_1

            # Print to stdout.
            ref_str = "This is what we print"
            prettyPrint(ref_str)

            # Check.
            if MPICommons.myRank() == 0:
                ref_str = ref_str + "\n"
            else:
                ref_str = ""
            self.assertEqual(stream_1.getvalue(), ref_str)

        finally:
            # Put the original stdout back.
            sys.stdout = original_sys_stdout

        # Print to another stream.
        stream_2 = StringIO.StringIO()
        ref_str = "This is what we print next time."
        prettyPrint(ref_str, output=stream_2)

        # Check.
        if MPICommons.myRank() == 0:
            ref_str = ref_str + "\n"
        else:
            ref_str = ""

        self.assertEqual(stream_2.getvalue(), ref_str)

    def flush(self):
        """ Write all buffers to file. """
        if not len(self.__step) < 1:

            # Make sure only master writes.
            if MPICommons.isMaster():

                # Write data to file.
                with open(self._trajectory_filename, 'a') as trajectory:
                    for i in range(len(self.__step)):

                        step = self.__step[i]
                        time = self.__time[i]
                        n_atoms = len(self.__atom_id_types[i])

                        trajectory.write("STEP %i\n"%(step))
                        trajectory.write("          %i\n"%(n_atoms))
                        trajectory.write("    TIME %15.10e\n"%(time))

                        for j in range(n_atoms):
                            t = self.__atom_id_types[i][j]
                            c = self.__atom_id_coordinates[i][j]
                            trajectory.write(" %16s   %15.10e %15.10e %15.10e  %i\n"%(t, c[0], c[1], c[2], j))

            # While the other processes wait.
            MPICommons.barrier()

            # Reset the buffers.
            self.__atom_id_types = []
            self.__atom_id_coordinates = []
            self.__time = []
            self.__step = []

 def tearDown(self):
     """ The tearDown method for test fixtures. """
     # Make sure to stop simultaneously.
     MPICommons.barrier()
     for f in self.__files_to_remove:
         # Make sure only master delets files, while slaves wait.
         if MPICommons.isMaster():
             os.remove(f)
         MPICommons.barrier()

    def testWriteHeader(self):
        """ Test the header output. """
        # Get a file name.
        name = os.path.abspath(os.path.dirname(__file__))
        name = os.path.join(name, "..", "..")
        name = os.path.join(name, "TestUtilities", "Scratch")
        trajectory_filename = os.path.join(name, "tmp_trajectory.xyz")

        if MPICommons.isMaster():
            self.__files_to_remove.append(trajectory_filename)

        # Setup the trajectory object.
        unit_cell = KMCUnitCell(cell_vectors=[[1.0, 0.0, 0.0],
                                              [0.0, 1.0, 0.0],
                                              [0.0, 0.0, 1.0]],
                                basis_points=[[0.0, 0.0, 0.0]])
        lattice = KMCLattice(unit_cell=unit_cell,
                             periodic=(True, True, True),
                             repetitions=(4,2,3))

        config = KMCConfiguration(lattice=lattice,
                                 types=["A","B","C"]*8)

        t = XYZTrajectory(trajectory_filename=trajectory_filename,
                          configuration=config,
                          max_buffer_size=12345,
                          max_buffer_time=123.0)

        if MPICommons.isMaster():

            # Check that the header was written.
            self.assertTrue(os.path.exists(trajectory_filename))

            # Check the content of the header.
            with open(trajectory_filename, "r") as f:
                content = f.read()

            ref_content = """KMCLib XYZ FORMAT VERSION 2013.10.15

CELL VECTORS
a: 1.0000000000e+00 0.0000000000e+00 0.0000000000e+00
b: 0.0000000000e+00 1.0000000000e+00 0.0000000000e+00
c: 0.0000000000e+00 0.0000000000e+00 1.0000000000e+00

REPETITIONS 4 2 3

PERIODICITY True True True

"""
            self.assertEqual( content, ref_content )

    def printResults(self, stream=sys.stdout):
        """
        Print the results to the stream.

        :param stream: The stream to print to.
        """
        # Only master writes.
        if MPICommons.isMaster():
            stream.write("%15s %15s %15s %12s\n"%("  time (t)", " count (n)", "(dn/dt)   ", "stdErr"))
            n_tot  = 0
	    actualTot = 0
            t = 0.0
            for i,n in enumerate(self.__data):
                # Calculate the values to present.
                t  = i * self.__time_interval
                actualTot += n
                dt = self.__time_interval
                n_tot += n
                dn     = n
                rateEst = self.__floatAnalInterval*dn/dt
                stdErr = self.__floatAnalInterval*math.sqrt(dn)/dt
                # Only for times != zero.
                if (i > 0):
                    stream.write("%15.5f %15i"%(t, n_tot) +"        "+ "{:.6E}".format(rateEst) +"        "+"{:.3E}".format(stdErr) +"\n")
            eqTime = self.__finalTime - self.__initialTime
            stream.write("\nOverall we counted the following number of counts in the following amount of time: " + "%6i"%(actualTot) + " " + "{:.6E}".format(eqTime))

    def testConstruction(self):
        """ Test that the XYZTrajectory object can be constructed. """
        filename = "abc123.xyz"
        name = os.path.abspath(os.path.dirname(__file__))
        name = os.path.join(name, "..", "..")
        name = os.path.join(name, "TestUtilities", "Scratch")
        filename = os.path.join(name, filename)

        if MPICommons.isMaster():
            self.__files_to_remove.append(filename)

        unit_cell = KMCUnitCell(cell_vectors=[[1.0, 0.0, 0.0],
                                              [0.0, 1.0, 0.0],
                                              [0.0, 0.0, 1.0]],
                                basis_points=[[0.0, 0.0, 0.0]])
        lattice = KMCLattice(unit_cell=unit_cell,
                             periodic=(True, True, True),
                             repetitions=(4,4,4))

        config = KMCConfiguration(lattice=lattice,
                                 types=["A","B","C","D"]*16)

        t = XYZTrajectory(trajectory_filename=filename,
                          configuration=config,
                          max_buffer_size=12345,
                          max_buffer_time=123.0)

        # Check that the internal memory buffers have been initiated.
        self.assertEqual(t._XYZTrajectory__atom_id_types, [])
        self.assertEqual(t._XYZTrajectory__atom_id_coordinates, [])
        self.assertEqual(t._XYZTrajectory__time, [])
        self.assertEqual(t._XYZTrajectory__step, [])

    def printResults(self, stream=sys.stdout):
        """
        Print the results to the stream.

        :param stream: The stream to print to.
        """
        # Only master writes.
        if MPICommons.isMaster():

            # The format string for the values.
            format_str = " %15.3e"*(len(self.__empty_count))
            format_str += "\n"

            # The format string for the counts.
            format_str_1 = " %15s"*(len(self.__empty_count))
            format_str_1 += "\n"

            types_str = ["time"]
            for t in self.__type_names[1:]:
                types_str.append(t)

            stream.write(format_str_1%tuple(types_str))

            for i,d in enumerate(self.__data):
                # Calculate the time.
                t  = i * self.__time_interval + (self.__time_interval / 2.0)

                # Append the values.
                tt = [t]
                for dd in d[1:]:
                    tt.append(dd)

                # Print.
                stream.write(format_str%tuple(tt))

    def printResults(self, stream=sys.stdout):
        """
        Print the results to the stream.

        :param stream: The stream to print to.
        """
        # Only master writes.
        if MPICommons.isMaster():
            stream.write("%15s %15s %15s %12s %12s\n"%("  time (t)", " count (n)", "(dn/dt)   ", "stdErr", "relErr"))
            n_tot  = 0
	    actualTot = 0
            t = 0.0
            for i,n in enumerate(self.__data):
                # Calculate the values to present.
                t  = i * self.__time_interval

		if t>=self.__transientTime:
                    actualTot += n

                dt = self.__time_interval
                n_tot += n
                dn     = n
                rateEst = dn/dt
                stdErr = math.sqrt(dn)/t
                # Only for times != zero.
                if i > 0:
                    stream.write("%15.5f %15i %15.5f %15.5f 15.5f\n"%(t, n_tot, rateEst, stdErr, 100.0*(stdErr/rateEst)))
            eqTime = t - self.__transientTime
            eqRate = actualTot/eqTime
            eqStdErr = math.sqrt(actualTot)/eqTime
            stream.write("\nThere were " + "%15i"%(actualTot) + " counts after equilibration. Therefore, the equilibrium rate estimate is " + "%15.5f"%(actualTot/eqTime) + "+/-" + "%15.5f"%(eqStdErr) + ".")

    def printResults(self, stream=sys.stdout):
        """
        Print the results to a stream.

        :param stream: The stream to print to. Defaults to 'sys.stdout'.
        """
        # Only master writes.
        if MPICommons.isMaster():

            # Bunch the results together and cutoff.
            cutoff_bin = self.safeCutoff()
            all_results = zip(self.__time_steps,
                              self.__results[0],
                              self.__results[1],
                              self.__results[2],
                              self.__results[3],
                              self.__results[4],
                              self.__results[5],
                              self.__results[6],
                              self.__std_dev[0],
                              self.__std_dev[1],
                              self.__std_dev[2],
                              self.__std_dev[3],
                              self.__std_dev[4],
                              self.__std_dev[5],
                              self.__std_dev[6],
                              self.__n_eff)[:cutoff_bin]
            stream.write("%11s %11s %11s %11s %11s %11s %11s %11s %11s %11s %11s %11s %11s %11s %11s %11s\n"%("TIME ", "MSD_x ", "DSD_y ", "MSD_z ", "MSD_xy ", "MSD_xz ", "MSD_yz ", "MSD_xyz ", "STD_x ", "STD_y ", "STD_z ", "STD_xy ", "STD_xz ", "STD_yz ", "STD_xyz ", "N_eff"))
            for t, x, y, z, xy, xz, yz, xyz, sx, sy, sz, sxy, sxz, syz, sxyz, nf in all_results:
                stream.write("%11.5e %11.5e %11.5e %11.5e %11.5e %11.5e %11.5e %11.5e %11.5e %11.5e %11.5e %11.5e %11.5e %11.5e %11.5e %11.5e\n"%(t, x, y, z, xy, xz, yz, xyz, sx, sy, sz, sxy, sxz, syz, sxyz, nf))

def prettyPrint(msg, output=None):
    """
    Utility function for printing an output string to screen.

    :param msg: The message to print.
    :type msg: str

    :param out: The stream to write to. Defaults to sys.stdout.
    """
    # Set the default.
    if output is None:
        output = sys.stdout

    # Write.
    if MPICommons.isMaster():
        output.write(msg)
        output.write("\n")
    MPICommons.barrier()

    def printResults(self, stream=sys.stdout):
        """
        Print the results to the stream.

        :param stream: The stream to print to.
        """
        # Only master writes.
        if MPICommons.isMaster():
            for item in self.__histogram:
                stream.write(str(item[0])+" "+str(item[1])+"\n")

    def __writeToFile(self, simulation_time_buffer, step_buffer, types_buffer):
        """
        Append the types and time information to the trajectory.
        The trajectory if flushed to file if the flush time limit has passed.

        :param simulation_time_buffer: A list of simulation times to be written to disk.
        :param step_buffer:            A list of step numbers to be written.
        :param types_buffer:           The types buffer given as a list of lists of strings.
        """
        # Save to file.

        # Make sure only master writes.
        if MPICommons.isMaster():
            with open(self.__trajectory_filename, 'a') as trajectory:
                for (sim_time, step, types) in zip(simulation_time_buffer, step_buffer, types_buffer):
                    trajectory.write( "times.append(%f)\n"%sim_time )
                    trajectory.write( "steps.append(%i)\n"%step )

                    # Write the types.
                    types_str = "types.append(["
                    indent = " "*14
                    row_length = len(types_str)
                    for t in types[:-1]:
                        row_length += len(t) + 2
                        types_str += "\"" + t + "\"" + ","

                        # Berak the row if above 70 positions.
                        if row_length >= 70:
                            types_str += "\n" + indent
                            row_length = len(indent)

                    # Add the last type.
                    types_str += "\"" + types[-1] + "\"" + "])\n"

                    # Write it to file.
                    trajectory.write(types_str)

        # While the others wait.
        MPICommons.barrier()

        # Update the time.
        self.__time_last_dump = time.time()