How to use the mpi4py.MPI.Get_processor_name function in mpi4py

def test():
    size = MPI.COMM_WORLD.Get_size()
    rank = MPI.COMM_WORLD.Get_rank()
    name = MPI.Get_processor_name()
    with Seq(MPI.COMM_WORLD, 1, 10):
        print(
            "Hello, World! I am process %d of %d on %s."
            % (rank, size, name))

def wait(self):
        """
        If this isn't the master process, wait for instructions.
        """
        if self.is_master():
            raise RuntimeError("master node told to await jobs")

        # logging info
        if self.subcomm.rank == 0:
            args = (self.rank, MPI.Get_processor_name(), self.subcomm.size)
            self.logger.info("worker master rank is %d on %s with %d processes available" %args)

        # continously loop and wait for instructions
        while True:
            args = None
            tag = -1

            # have the master rank of the subcomm ask for task and then broadcast
            if self.subcomm.rank == 0:
                self.comm.send(None, dest=0, tag=self.tags.READY)
                args = self.comm.recv(source=0, tag=MPI.ANY_TAG, status=self.status)
                tag = self.status.Get_tag()
            
            # bcast to everyone in the worker subcomm
            args  = self.subcomm.bcast(args)
            tag   = self.subcomm.bcast(tag)

"""
        )

h = "Data source to read particle position:\n\n"
parser.add_argument("datasource", type=DataSource.fromstring,
        help=h + DataSource.format_help())
parser.add_argument("LinkingLength", type=float, 
        help='LinkingLength in mean separation (0.2)')
parser.add_argument("output", help='output file; output.grp.N and output.halo are written')
parser.add_argument("--nmin", type=float, default=32, help='minimum number of particles in a halo')

ns = parser.parse_args()
from mpi4py import MPI

rank = MPI.COMM_WORLD.rank
name = MPI.Get_processor_name().split('.')[0]
logging.basicConfig(level=logging.DEBUG,
                    format='rank %d on %s: '%(rank,name) + \
                            '%(asctime)s %(name)-15s %(levelname)-8s %(message)s',
                    datefmt='%m-%d %H:%M:%S')


from nbodykit.fof import fof

def main():
    comm = MPI.COMM_WORLD

    catalogue, labels = fof(ns.datasource, ns.LinkingLength, ns.nmin, comm, return_labels=True)
    Ntot = comm.allreduce(len(labels))

    if comm.rank == 0:
        with h5py.File(ns.output + '.hdf5', 'w') as ff:

def setup_logging(log_level):
    """
    Set the basic configuration of all loggers
    """

    # This gives:
    #
    # [ 000000.43 ]   0:waterfall 06-28 14:49  measurestats    INFO     Nproc = [2, 1, 1]
    # [ 000000.43 ]   0:waterfall 06-28 14:49  measurestats    INFO     Rmax = 120

    import time
    logger = logging.getLogger();
    t0 = time.time()

    rank = MPI.COMM_WORLD.rank
    name = MPI.Get_processor_name().split('.')[0]

    class Formatter(logging.Formatter):
        def format(self, record):
            s1 = ('[ %09.2f ] % 3d:%s ' % (time.time() - t0, rank, name))
            return s1 + logging.Formatter.format(self, record)

    fmt = Formatter(fmt='%(asctime)s %(name)-15s %(levelname)-8s %(message)s',
                    datefmt='%m-%d %H:%M ')

    hdlr = logging.StreamHandler()
    hdlr.setFormatter(fmt)
    logger.addHandler(hdlr)
    logger.setLevel(log_level)

def setup_logging(log_level):
    """
    Set the basic configuration of all loggers
    """

    # This gives:
    #
    # [ 000000.43 ]   0:waterfall 06-28 14:49  measurestats    INFO     Nproc = [2, 1, 1]
    # [ 000000.43 ]   0:waterfall 06-28 14:49  measurestats    INFO     Rmax = 120

    import time
    logger = logging.getLogger();
    t0 = time.time()

    rank = MPI.COMM_WORLD.rank
    name = MPI.Get_processor_name().split('.')[0]

    class Formatter(logging.Formatter):
        def format(self, record):
            s1 = ('[ %09.2f ] % 3d:%s ' % (time.time() - t0, rank, name))
            return s1 + logging.Formatter.format(self, record)

    fmt = Formatter(fmt='%(asctime)s %(name)-15s %(levelname)-8s %(message)s',
                    datefmt='%m-%d %H:%M ')

    hdlr = logging.StreamHandler()
    hdlr.setFormatter(fmt)
    logger.addHandler(hdlr)
    logger.setLevel(log_level)

print(
                            "[controller {}] unrecognized message from source {} with tag {}:\n{}".format(
                                datetime.datetime.now().isoformat(), source, tag, msg
                            )
                        )
                print(
                    "[controller {}] all workers have exited".format(
                        datetime.datetime.now().isoformat()
                    )
                )
        else:
            # this process is a worker
            self.initialize_worker()
            worker_t0 = time.time()
            task_count = 0
            name = MPI.Get_processor_name()
            print(
                "[worker {} {}] running on {}".format(
                    rank, datetime.datetime.now().isoformat(), name
                )
            )
            while True:
                print(
                    "[worker {} {}] sending request for work".format(
                        rank, datetime.datetime.now().isoformat()
                    )
                )
                comm.send(None, dest=0, tag=READY_)
                print(
                    "[worker {} {}] waiting for work".format(
                        rank, datetime.datetime.now().isoformat()
                    )

def __init__(self):
        # Initialize communicator and obtain standard MPI variables
        comm = MPI.COMM_WORLD

        self.comm = comm
        self.rank = comm.Get_rank()
        self.num_procs = comm.Get_size()
        self.name = MPI.Get_processor_name()

        # Define master rank
        self.master_rank = 0

        # Define message tags for task, result, and announce
        self.task_tag = 10
        self.result_tag = 20
        self.announce_tag = 30

        # create an empty message buffer
        messages = []

Python code blocks in input file.
        optparams (dict): Optional argument. For Taguchi optimisation it
                provides the parameters to optimise and their values.
    """

    from mpi4py import MPI

    # Define MPI message tags
    tags = Enum('tags', {'READY': 0, 'DONE': 1, 'EXIT': 2, 'START': 3})

    # Initializations and preliminaries
    comm = MPI.COMM_WORLD
    size = comm.Get_size()  # total number of processes
    rank = comm.Get_rank()  # rank of this process
    status = MPI.Status()   # get MPI status object
    hostname = MPI.Get_processor_name()     # get name of processor/host

    # Set range for number of models to run
    modelstart = args.restart if args.restart else 1
    modelend = modelstart + args.n
    numbermodelruns = args.n
    currentmodelrun = modelstart  # can use -task argument to start numbering from something other than 1
    numworkers = size - 1

    ##################
    # Master process #
    ##################
    if rank == 0:
        tsimstart = timer()
        mpistartstr = '\n=== MPI task farm (WITHOUT using MPI Spawn)'
        print('{} {}'.format(mpistartstr, '=' * (get_terminal_width() - 1 - len(mpistartstr))))
        print('=== MPI master ({}, rank: {}) on {} using {} workers...'.format(comm.name, comm.Get_rank(), hostname, numworkers))

Sequence of elements supplied to the workers.

    :Optional:
        args : tuple
            Additional constant arguments supplied to function.
        debug : bool=False
            Be very verbose (for debugging purposes).

    """
    debug = 'debug' in kwargs
    if debug:
        del kwargs['debug']

    rank = MPI.COMM_WORLD.Get_rank()
    assert rank == 0, "rank has to be 0."
    proc_name = MPI.Get_processor_name()
    status = MPI.Status()

    process_list = range(1, MPI.COMM_WORLD.Get_size())
    workers_done = []
    results = {}
    if debug: print "Data:", sequence

    # Instead of distributing the actual elements, we just distribute
    # the index as the workers already have the sequence. This allows
    # objects to be used as well.
    queue = iter(xrange(len(sequence)))

    if debug: print "Controller %i on %s: ready!" % (rank, proc_name)

    # Feed all queued jobs to the childs
    while(True):

names = {}
    if rank == 0:
        for n, r in nameRanks:
            if n not in names:
                names[n] = []
            names[n].append(r)
        for n in names:
            names[n].sort()
    names = mpi.bcast(names, root=0)
    return names[name].index(rank), len(names[name])

try:
    from mpi4py import MPI
    mpi = MPI.COMM_WORLD
    nProcessors = mpi.Get_size()
    name = MPI.Get_processor_name()
    rank = mpi.Get_rank()
    localRank, nRanksPerNode = getLocalRank(mpi, name, rank)
    #mpsRank = localRank % 2
    #os.environ['CUDA_MPS_PIPE_DIRECTORY'] = '/tmp/nvidia-pipe-{}'.format(mpsRank)
    #os.environ['CUDA_MPS_LOG_DIRECTORY'] = '/tmp/nvidia-log-{}'.format(mpsRank)
except:
    print('mpi4py NOT LOADED: YOU SHOULD BE RUNNING ON A SINGLE CORE')
    class Container(object):
        pass
    mpi = Container()
    nProcessors = 1
    name = ''
    rank = 0
    localRank, nRanksPerNode = 0, 1
    mpi.bcast = lambda x, root: x
    mpi.Bcast = lambda x, root: None