Make copies of direct-Field and duplicate tasks to avoid processing issues and transform noise in coeff outputs

Author: kburns

dedalus/core/evaluator.py

@@ -13,6 +13,7 @@
 
 from .future import FutureField, FutureLockedField
 from .field import Field, LockedField
+from .operators import Copy
 from ..tools.cache import CachedAttribute
 from ..tools.general import OrderedSet
 from ..tools.general import oscillate
@@ -127,22 +128,19 @@ def evaluate_handlers(self, handlers, id=None, **kw):
             # Attempt evaluation
             tasks = self.attempt_tasks(tasks, id=id)
 
-        # # Transform all outputs to coefficient layout to dealias
-        ## D3 note: need to worry about this for redundent tasks?
-        # outputs = OrderedSet([t['out'] for h in handlers for t in h.tasks])
-        # self.require_coeff_space(outputs)
-
-        # # Copy redundant outputs so processing is independent
-        # outputs = set()
-        # for handler in handlers:
-        #     for task in handler.tasks:
-        #         if task['out'] in outputs:
-        #             task['out'] = task['out'].copy()
-        #         else:
-        #             outputs.add(task['out'])
+        # Transform all outputs to coefficient layout to dealias
         outputs = OrderedSet([t['out'] for h in handlers for t in h.tasks if not isinstance(t['out'], LockedField)])
         self.require_coeff_space(outputs)
 
+        # Copy redundant outputs so processing is independent
+        outputs = set()
+        for handler in handlers:
+            for task in handler.tasks:
+                if task['out'] in outputs:
+                    task['out'] = task['out'].copy()
+                else:
+                    outputs.add(task['out'])
+
         # Process
         for handler in handlers:
             handler.process(**kw)
@@ -285,10 +283,9 @@ def add_task(self, task, layout='g', name=None, scales=None):
         # Create operator
         if isinstance(task, str):
             op = FutureField.parse(task, self.vars, self.dist)
+        elif isinstance(task, Field):
+            op = Copy(task)
         else:
-            # op = FutureField.cast(task, self.domain)
-            # op = Cast(task)
-            # TODO: figure out if we need to copying here
             op = task
         # Check scales
         if isinstance(op, (LockedField, FutureLockedField)):

dedalus/core/operators.py

@@ -19,7 +19,7 @@
 
 from .domain import Domain
 from . import coords
-from .field import Operand, Field
+from .field import Operand, Field, LockedField
 from .future import Future, FutureField, FutureLockedField
 from ..tools.array import reshape_vector, apply_matrix, add_sparse, axindex, axslice, perm_matrix, copyto, sparse_block_diag, interleave_matrices
 from ..tools.cache import CachedAttribute, CachedMethod
@@ -1492,6 +1492,8 @@ class Copy(LinearOperator):
 
     def __init__(self, operand, out=None):
         super().__init__(operand, out=out)
+        if isinstance(operand, (LockedField, FutureLockedField)):
+            raise ValueError("Not yet implemented for locked fields.")
         # LinearOperator requirements
         self.operand = operand
         # FutureField requirements