Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Risultati delle attività in una definizione di HealthOmics flusso di lavoro
<a name="workflows-task-outputs"></a>

Gli output delle attività vengono specificati nella definizione del flusso di lavoro. Per impostazione predefinita, HealthOmics elimina tutti i file di attività intermedi al termine del flusso di lavoro. Per esportare un file intermedio, lo si definisce come output. 

Se si utilizza la memorizzazione nella cache delle chiamate, HealthOmics salva gli output delle attività nella cache, inclusi tutti i file intermedi definiti come output.

I seguenti argomenti includono esempi di definizione delle attività per ciascuno dei linguaggi di definizione del flusso di lavoro.

**Topics**
+ [Output delle attività per WDL](#workflow-task-outputs-wdl)
+ [Output delle attività per Nextflow](#workflow-task-outputs-nextflow)
+ [Output delle attività per CWL](#workflow-task-outputs-cwl)

## Output delle attività per WDL
<a name="workflow-task-outputs-wdl"></a>

Per le definizioni dei flussi di lavoro scritte in WDL, definite i risultati nella sezione Workflow di primo livello. **outputs** 

HealthOmics

**Topics**
+ [Output delle attività per STDOUT](#task-outputs-wdl-stdout)
+ [Output dell'attività per STDERR](#task-outputs-wdl-stderr)
+ [Emissione dell'operazione in un file](#task-outputs-wdl-file)
+ [Emissione dell'operazione su una serie di file](#task-outputs-wdl-files)

### Output delle attività per STDOUT
<a name="task-outputs-wdl-stdout"></a>

Questo esempio crea un'attività denominata `SayHello` che riproduce il contenuto STDOUT nel file di output dell'operazione. **La **stdout** funzione WDL acquisisce il contenuto STDOUT (in questo esempio, la stringa di input Hello World\$1** ) nel file. **stdout\$1file** 

Poiché HealthOmics crea registri per tutto il contenuto STDOUT, l'output viene visualizzato anche in CloudWatch Logs, insieme ad altre informazioni di registrazione STDERR relative all'attività.

```
version 1.0
 workflow HelloWorld {
    input {
        String message = "Hello, World!"
        String ubuntu_container = "123456789012.dkr.ecr.us-east-1.amazonaws.com/dockerhub/library/ubuntu:20.04"
    }

    call SayHello {
        input:
            message = message,
            container = ubuntu_container
    }

    output {
        File stdout_file = SayHello.stdout_file
    }
}

task SayHello {
    input {
        String message
        String container
    }

    command <<<
        echo "~{message}" 
        echo "Current date: $(date)"
        echo "This message was printed to STDOUT"
    >>>

    runtime {
        docker: container
        cpu: 1
        memory: "2 GB"
    }

    output {
        File stdout_file = stdout()
    }
}
```

### Output dell'attività per STDERR
<a name="task-outputs-wdl-stderr"></a>

Questo esempio crea un'attività denominata `SayHello` che riproduce il contenuto STDERR del file di output dell'operazione. **La **stderr** funzione WDL acquisisce il contenuto STDERR (in questo esempio, la stringa di input Hello World\$1** ) nel file. **stderr\$1file** 

Poiché HealthOmics crea registri per tutto il contenuto STDERR, l'output verrà visualizzato in CloudWatch Logs, insieme ad altre informazioni di registrazione STDERR relative all'attività.

```
version 1.0
 workflow HelloWorld {
    input {
        String message = "Hello, World!"
        String ubuntu_container = "123456789012.dkr.ecr.us-east-1.amazonaws.com/dockerhub/library/ubuntu:20.04"
    }

    call SayHello {
        input:
            message = message,
            container = ubuntu_container
    }

    output {
        File stderr_file = SayHello.stderr_file
    }
}

task SayHello {
    input {
        String message
        String container
    }

    command <<<
        echo "~{message}" >&2
        echo "Current date: $(date)" >&2
        echo "This message was printed to STDERR" >&2
    >>>

    runtime {
        docker: container
        cpu: 1
        memory: "2 GB"
    }

    output {
        File stderr_file = stderr()
    }
}
```

### Emissione dell'operazione in un file
<a name="task-outputs-wdl-file"></a>

In questo esempio, l' SayHello attività crea due file (message.txt e info.txt) e li dichiara esplicitamente come output denominato (message\$1file e info\$1file). 

```
version 1.0
workflow HelloWorld {
    input {
        String message = "Hello, World!"
        String ubuntu_container = "123456789012.dkr.ecr.us-east-1.amazonaws.com/dockerhub/library/ubuntu:20.04"
    }

    call SayHello {
        input:
            message = message,
            container = ubuntu_container
    }

    output {
        File message_file = SayHello.message_file
        File info_file = SayHello.info_file
    }
}

task SayHello {
    input {
        String message
        String container
    }

    command <<<
        # Create message file
        echo "~{message}" > message.txt
        
        # Create info file with date and additional information
        echo "Current date: $(date)" > info.txt
        echo "This message was saved to a file" >> info.txt
    >>>

    runtime {
        docker: container
        cpu: 1
        memory: "2 GB"
    }

    output {
        File message_file = "message.txt"
        File info_file = "info.txt"
    } 
}
```

### Emissione dell'operazione su una serie di file
<a name="task-outputs-wdl-files"></a>

In questo esempio, l'`GenerateGreetings`attività genera una serie di file come output dell'operazione. L'operazione genera dinamicamente un file di saluto per ogni membro dell'array di input. `names` Poiché i nomi dei file non sono noti fino all'esecuzione, la definizione di output utilizza la funzione WDL glob () per generare tutti i file che corrispondono al modello. `*_greeting.txt` 

```
version 1.0
 workflow HelloArray {
    input {
        Array[String] names = ["World", "Friend", "Developer"]
        String ubuntu_container = "123456789012.dkr.ecr.us-east-1.amazonaws.com/dockerhub/library/ubuntu:20.04"
    }

    call GenerateGreetings {
        input:
            names = names,
            container = ubuntu_container
    }

    output {
        Array[File] greeting_files = GenerateGreetings.greeting_files
    }
}

task GenerateGreetings {
    input {
        Array[String] names
        String container
    }

    command  <<<
        # Create a greeting file for each name
        for name in ~{sep=" " names}; do
            echo "Hello, $name!" > ${name}_greeting.txt
        done
    >>>

    runtime {
        docker: container
        cpu: 1
        memory: "2 GB"
    }

    output {
        Array[File] greeting_files = glob("*_greeting.txt")
    }       
 }
```

## Output delle attività per Nextflow
<a name="workflow-task-outputs-nextflow"></a>

Per le definizioni dei flussi di lavoro scritte in Nextflow, definisci una direttiva **PublishDir** per esportare il contenuto delle attività nel tuo bucket Amazon S3 di output. **`/mnt/workflow/pubdir`Imposta** il valore PublishDir su. 

 HealthOmics Per esportare file in Amazon S3, i file devono trovarsi in questa directory.

Se un'operazione produce un gruppo di file di output da utilizzare come input per un'attività successiva, consigliamo di raggruppare questi file in una directory e di emettere la directory come output dell'attività. L'enumerazione di ogni singolo file può causare un collo di bottiglia di I/O nel file system sottostante. Per esempio:

```
process my_task {
      ...
      // recommended
      output "output-folder/", emit: output
      
      // not recommended
      // output "output-folder/**", emit: output
      ...
  }
```

## Output delle attività per CWL
<a name="workflow-task-outputs-cwl"></a>

Per le definizioni dei flussi di lavoro scritte in CWL, è possibile specificare gli output delle attività utilizzando le attività. `CommandLineTool` Le sezioni seguenti mostrano esempi di `CommandLineTool` attività che definiscono diversi tipi di output.

**Topics**
+ [Output delle attività per STDOUT](#task-outputs-cwl-stdout)
+ [Output dell'attività per STDERR](#task-outputs-cwl-stderr)
+ [Emissione dell'operazione in un file](#task-outputs-cwl-file)
+ [Esecuzione dell'operazione su una serie di file](#task-outputs-cwl-files)

### Output delle attività per STDOUT
<a name="task-outputs-cwl-stdout"></a>

Questo esempio crea un'`CommandLineTool`attività che riproduce il contenuto STDOUT in un file di output di testo denominato. **output.txt** **Ad esempio, se fornite il seguente input, l'output dell'attività risultante è Hello World\$1** nel **output.txt** file.

```
{
    "message": "Hello World!"
}
```

La `outputs` direttiva specifica che il nome dell'output è **example\$1out** e il suo tipo è`stdout`. Affinché un'attività a valle consumi l'output di questa attività, si riferirebbe all'output come. `example_out`

Poiché HealthOmics crea registri per tutto il contenuto STDERR e STDOUT, l'output viene visualizzato anche in CloudWatch Logs, insieme ad altre informazioni di registrazione STDERR relative all'attività.

```
cwlVersion: v1.2
class: CommandLineTool
baseCommand: echo
stdout: output.txt
inputs:
  message:
    type: string
    inputBinding:
      position: 1
outputs:
  example_out:
    type: stdout

requirements:
    DockerRequirement:
        dockerPull: 123456789012.dkr.ecr.us-east-1.amazonaws.com/dockerhub/library/ubuntu:20.04
    ResourceRequirement:
        ramMin: 2048
        coresMin: 1
```

### Output dell'attività per STDERR
<a name="task-outputs-cwl-stderr"></a>

Questo esempio crea un'`CommandLineTool`attività che riproduce il contenuto STDERR in un file di output di testo denominato. **stderr.txt** L'attività modifica il codice in `baseCommand` modo che venga `echo` scritto su STDERR (anziché su STDOUT).

La `outputs` direttiva specifica che il nome dell'output è e il tipo è**stderr\$1out**. `stderr` 

Poiché HealthOmics crea registri per tutto il contenuto STDERR e STDOUT, l'output verrà visualizzato in CloudWatch Logs, insieme ad altre informazioni di registrazione STDERR relative all'attività.

```
cwlVersion: v1.2
class: CommandLineTool
baseCommand: [bash, -c]
stderr: stderr.txt
inputs:
  message:
    type: string
    inputBinding:
      position: 1
      shellQuote: true
      valueFrom: "echo $(self) >&2"
outputs:
  stderr_out:
    type: stderr

requirements:
    DockerRequirement:
        dockerPull: 123456789012.dkr.ecr.us-east-1.amazonaws.com/dockerhub/library/ubuntu:20.04
    ResourceRequirement:
        ramMin: 2048
        coresMin: 1
```

### Emissione dell'operazione in un file
<a name="task-outputs-cwl-file"></a>

Questo esempio crea un'`CommandLineTool`attività che crea un archivio tar compresso dai file di input. Fornite il nome dell'archivio come parametro di input (archive\$1name). 

La **outputs** direttiva specifica che il tipo di `archive_file` output è `File` e utilizza un riferimento al parametro di input per collegarsi `archive_name` al file di output.

```
cwlVersion: v1.2
class: CommandLineTool
baseCommand: [tar, cfz]
inputs:
  archive_name:
    type: string
    inputBinding:
      position: 1
  input_files:
    type: File[]
    inputBinding:
      position: 2
      
outputs:
  archive_file:
    type: File
    outputBinding:
      glob: "$(inputs.archive_name)"

requirements:
    DockerRequirement:
        dockerPull: 123456789012.dkr.ecr.us-east-1.amazonaws.com/dockerhub/library/ubuntu:20.04
    ResourceRequirement:
        ramMin: 2048
        coresMin: 1
```

### Esecuzione dell'operazione su una serie di file
<a name="task-outputs-cwl-files"></a>

In questo esempio, l'`CommandLineTool`attività crea una matrice di file utilizzando il `touch` comando. Il comando utilizza le stringhe del parametro `files-to-create` di input per denominare i file. Il comando genera una serie di file. L'array include tutti i file nella directory di lavoro che corrispondono al `glob` modello. Questo esempio utilizza un pattern di caratteri jolly («\$1») che corrisponde a tutti i file.

```
cwlVersion: v1.2
class: CommandLineTool
baseCommand: touch
inputs:
  files-to-create:
    type:
      type: array
      items: string
    inputBinding:
      position: 1
outputs:
  output-files:
    type:
      type: array
      items: File
    outputBinding:
      glob: "*"

requirements:
    DockerRequirement:
        dockerPull: 123456789012.dkr.ecr.us-east-1.amazonaws.com/dockerhub/library/ubuntu:20.04
    ResourceRequirement:
        ramMin: 2048
        coresMin: 1
```