docs: def _make_outputnode(self, frequency):
          """
          Generates an output node for the given frequency. It also adds implicit
          file format conversion nodes to the pipeline.
  
          Parameters
          ----------
          frequency : str
              The frequency (i.e. 'per_session', 'per_visit', 'per_subject' or
              'per_study') of the output node to retrieve
          """
          # Check to see whether there are any outputs for the given frequency
          outputs = list(self.frequency_outputs(frequency))
          if not outputs:
              raise ArcanaError(
                  "No outputs to '{}' pipeline for requested freqency '{}'"
                  .format(self.name, frequency))
          # Get list of output names for the requested frequency, addding fields
          # to hold iterator IDs
          output_names = [o.name for o in outputs]
          # Generate output node and connect it to appropriate nodes
          outputnode = self.add('{}_outputnode'.format(frequency),
                                IdentityInterface(fields=output_names))
          # Loop through list of nodes connected to study data specs and
          # connect them to the newly created output node
          for output in outputs:  # @ReservedAssignment
              (node, node_out, format,  # @ReservedAssignment @IgnorePep8
               conv_kwargs) = self._output_conns[output.name]
              # If fileset formats differ between study and pipeline
              # outputs create converter node (if one hasn't been already)
              # and connect output to that before connecting to outputnode
              if self.requires_conversion(output, format):
                  conv = output.format.converter_from(format, **conv_kwargs)
                  node = self.add(
                      'conv_{}_from_{}_format'.format(output.name, format.name),
                      conv.interface,
                      inputs={conv.input: (node, node_out)},
                      requirements=conv.requirements,
                      mem_gb=conv.mem_gb,
                      wall_time=conv.wall_time)
                  node_out = conv.output
              self.connect(node, node_out, outputnode, output.name)
          return outputnode