1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
#!/usr/bin/env python
#
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#
#<LicenseText>
#
# CitcomS.py by Eh Tan, Eun-seo Choi, and Pururav Thoutireddy.
# Copyright (C) 2002-2005, California Institute of Technology.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
#</LicenseText>
#
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#


from pyre.components.Component import Component


class Layout(Component):


    def __init__(self, name, facility):
        Component.__init__(self, name, facility)

        self.ccomm = None
        self.ecomm = None
        self.ccommPlus = []
        self.ecommPlus = []

        self.comm = None
        self.rank = 0
        self.nodes = 0
        return



    def initialize(self, application):
        self.discover()
        self.verify(application)
        self.createCommunicators()
        return



    def discover(self):
        '''Find the size/rank of the whole application.
        '''
        import mpi
        self.comm = mpi.world()
        self.rank = self.comm.rank
        self.nodes = self.comm.size
        return



    def verify(self, application):
        # check do we have at least 2 processor
        if self.nodes < 2:
            import journal
            firewall = journal.firewall("layout")
            firewall.log("'%s' requires at least 2 processors"
                         % application.name)

        containing_group = self.inventory.containing_group
        embedded_group = self.inventory.embedded_group

        # check no duplicated elements in the group
        self.check_duplicated(containing_group)
        self.check_duplicated(embedded_group)

        # check the two groups are disjoint
        self.check_disjoint(containing_group, embedded_group)

        return



    def check_duplicated(self, group):
        s = set(group)
        if len(s) != len(group):
            import journal
            firewall = journal.firewall("layout")
            firewall.log('Duplicated element in group: %s' % group)
        return



    def check_disjoint(self, group0, group1):
        s0 = set(group0)
        s1 = set(group1)
        if s0.intersection(s1):
            import journal
            firewall = journal.firewall("layout")
            firewall.log('Groups are not disjoint: %s and %s' % (group0, group1))
        return



    def createCommunicators(self):
        '''Create various communicators for solvers and couplers
        '''
        world = self.comm
        myrank = self.rank
        containing_group = self.inventory.containing_group
        embedded_group = self.inventory.embedded_group

        # Communicator for solvers
        self.ccomm = world.include(containing_group)
        self.ecomm = world.include(embedded_group)

        # Communicator for inter-solver communication
        # Each node in containing_group will form a communicator
        # with the nodes in embedded_group
        for node in containing_group:
            self.ecommPlus.append(world.include(embedded_group + [node]))

        # Ditto for each node containing_group
        for node in embedded_group:
            self.ccommPlus.append(world.include(containing_group + [node]))

        return



    class Inventory(Component.Inventory):

        import pyre.inventory

        # The containing solver will run on these nodes
        containing_group = pyre.inventory.slice("containing_group",
                                                default=range(12))

        # The embedded solver will run on these nodes
        embedded_group = pyre.inventory.slice("embedded_group",
                                              default=[12])



# version
__id__ = "$Id$"

# End of file