Changeset 2706

Timestamp:

02/03/12 01:35:40 (4 months ago)

Author:

joni

Message:

fix: pakotettujen toimenpiteiden tekemien branchien huomioiminen

File:

• simo/trunk/src/simo/simulation/sim.py (modified) (1 diff)

simo/trunk/src/simo/simulation/sim.py

@@ -1202 +1202 @@
         # check if any of the active units has forced operations during the
         # current time step
-        tind, torem = self.data.get_tind(self.main_level, 0)
-        ids = self.data.get_id(self.main_level, tind)
         keys = set(self._forced_operations.keys())
-        # get the current and initial dates for all objects
-        dates = self.data.get_date(tind)
-        # go through each simulation unit and evaluate forced operations for
-        # a single unit at a time
-        # NB: evaluating forced operation chains for a single
-        # (iteration,branch,unit) may not be very efficient
-        tslev, tsind = self._ctrl.built_ins[names.TIME_STEP]
-        timesteps, err = self.data.get_value(tind, tsind)
-        if self.timespan.unit == names.YEAR:
-            years, months, days = timesteps, 0, 0
-        elif self.timespan.unit == names.MONTH:
-            years, months, days = 0, timesteps, 0
-        indset = set(range(tind.shape[0]))
-        for i in range(tind.shape[0]):
-            key = (self._start_iter + tind[i,0], tind[i,1], ids[i][0])
-            if key not in keys:
-                continue
-            self._blocked_forced.append(tind[i])
-            # define current simulation time step end date
+        for fkey in keys:
+            tind, torem = self.data.get_tind(self.main_level, 0)
+            ids = self.data.get_id(self.main_level, tind)
+            # get the current and initial dates for all objects
+            dates = self.data.get_date(tind)
+            # go through each simulation unit and evaluate forced 
+            # operations for a single unit at a time
+            # NB: evaluating forced operation chains for a single
+            # (iteration,branch,unit) may not be very efficient
+            tslev, tsind = self._ctrl.built_ins[names.TIME_STEP]
+            timesteps, err = self.data.get_value(tind, tsind)
             if self.timespan.unit == names.YEAR:
-                end_date = date(dates[i].year + int(years[i]),
-                                dates[i].month + months,
-                                dates[i].day + days)
-                end_date += relativedelta(days=-1)
+                years, months, days = timesteps, 0, 0
             elif self.timespan.unit == names.MONTH:
-                yr = int(months[i] / 12.)
-                mo = int(months[i] % 12.)
-                end_date = date(dates[i].year + yr,
-                                dates[i].month + mo,
-                                dates[i].day + days)
-                end_date += relativedelta(days=-1)
-            # make sure the end_date is also smaller than the ending date.
-            if self.timespan.ending.type == 'end_date':
-                # if time step is 0, set the run end as end_date, otherwise
-                # this is for cases when the current time step is the last one
-                # and the time step has been set to zero to skip growing
-                run_end = self.timespan.ending.target
-                if timesteps[i] == 0:
-                    end_date = run_end
-                else:
-                    end_date = min(end_date, run_end)
-            # go through the current simulation unit's forced operations
-            ops, rem = [], []
-            for j, op in enumerate(self._forced_operations[key]):
-                # if forced operation should be evaluated during the current
-                # time step, store the unit id to operation evaluation list
-                if op.date >= dates[i] and op.date <= end_date:
-                    ops.append(op)
-                    rem.insert(0, j)
-            for j in rem:
-                self._forced_operations[key].pop(j)
-            if len(self._forced_operations[key]) == 0:
-                del self._forced_operations[key]
-            for op in ops:
-                self._curr_forced_op_id = op.op_id
-                # block all other objects
-                block = list(indset.difference((i,)))
-                self.data.block(self.main_level, 0, tind[block,:], True)
-                ind = []
-                for focind in self._forced_chain_index:
-                    mccind = [focind[c] for c in op.chain_names if c in focind]
-                    ind.append(mccind)
-                orig_values = self._update_data(tind[(i,),:], op.data_values)
-                # evaluate the forced operation model chains
-                self._curr_op_type = 'forced'
-                self._evaluate_chains('forced_operation', ind)
-                self._curr_op_type = 'simulated'
-                op.data_values = self._update_data(tind[(i,),:], orig_values)
-                # release the blocked objects
-                self.data.release(self.main_level, 0, tind[block,:], True,
-                                  False)
-            self._curr_forced_op_id = None
+                years, months, days = 0, timesteps, 0
+            indset = set(range(tind.shape[0]))
+            for i in range(tind.shape[0]):
+                key = (self._start_iter + tind[i,0], tind[i,1], ids[i][0])
+                if key != fkey:
+                    continue
+                self._blocked_forced.append(tind[i])
+                # define current simulation time step end date
+                if self.timespan.unit == names.YEAR:
+                    end_date = date(dates[i].year + int(years[i]),
+                                    dates[i].month + months,
+                                    dates[i].day + days)
+                    end_date += relativedelta(days=-1)
+                elif self.timespan.unit == names.MONTH:
+                    yr = int(months[i] / 12.)
+                    mo = int(months[i] % 12.)
+                    end_date = date(dates[i].year + yr,
+                                    dates[i].month + mo,
+                                    dates[i].day + days)
+                    end_date += relativedelta(days=-1)
+                # make sure the end_date is also smaller than the ending date.
+                if self.timespan.ending.type == 'end_date':
+                    # if time step is 0, set the run end as end_date, otherwise
+                    # this is for cases when the current time step is 
+                    # the last one and the time step has been set to zero 
+                    # to skip growing
+                    run_end = self.timespan.ending.target
+                    if timesteps[i] == 0:
+                        end_date = run_end
+                    else:
+                        end_date = min(end_date, run_end)
+                # go through the current simulation unit's forced operations
+                ops, rem = [], []
+                for j, op in enumerate(self._forced_operations[key]):
+                    # if forced operation should be evaluated during 
+                    # the current time step, store the unit id to 
+                    # operation evaluation list
+                    if op.date >= dates[i] and op.date <= end_date:
+                        ops.append(op)
+                        rem.insert(0, j)
+                for j in rem:
+                    self._forced_operations[key].pop(j)
+                if len(self._forced_operations[key]) == 0:
+                    del self._forced_operations[key]
+                for op in ops:
+                    self._curr_forced_op_id = op.op_id
+                    block = list(indset.difference((i,)))
+                    self.data.block(self.main_level, 0, tind[block,:], True)
+                    ind = []
+                    for focind in self._forced_chain_index:
+                        mccind = [focind[c] for c in op.chain_names \
+                                  if c in focind]
+                        ind.append(mccind)
+                    orig_values = self._update_data(tind[(i,),:], 
+                                                    op.data_values)
+                    # evaluate the forced operation model chains
+                    self._curr_op_type = 'forced'
+                    self._evaluate_chains('forced_operation', ind)
+                    self._curr_op_type = 'simulated'
+                    op.data_values = self._update_data(tind[(i,),:], 
+                                                       orig_values)
+                    # release the blocked objects
+                    self.data.release(self.main_level, 0, tind[block,:], 
+                                      True, False)
+                self._curr_forced_op_id = None
+                break
         if len(self._blocked_forced) > 0:
             self._blocked_forced = numpy.array(self._blocked_forced)