Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Archivos de plantillas de parámetros para HealthOmics flujos de trabajo
<a name="parameter-templates"></a>

Las plantillas de parámetros definen los parámetros de entrada de un flujo de trabajo. Puede definir los parámetros de entrada para que su flujo de trabajo sea más flexible y versátil. Por ejemplo, puede definir un parámetro para la ubicación en Amazon S3 de los archivos del genoma de referencia. Las plantillas de parámetros se pueden proporcionar a través de un servicio de repositorio basado en Git o de su unidad local. A continuación, los usuarios pueden ejecutar el flujo de trabajo utilizando varios conjuntos de datos. 

Puede crear la plantilla de parámetros para su flujo de trabajo o HealthOmics puede generar la plantilla de parámetros automáticamente.

La plantilla de parámetros es un archivo JSON. En el archivo, cada parámetro de entrada es un objeto con nombre que debe coincidir con el nombre de la entrada del flujo de trabajo. Cuando se inicia una ejecución, si no se proporcionan valores para todos los parámetros necesarios, se produce un error en la ejecución.

El objeto de parámetro de entrada incluye los siguientes atributos:
+ **description**— Este atributo obligatorio es una cadena que la consola muestra en la página de **inicio de la ejecución**. Esta descripción también se conserva como metadatos de ejecución.
+ **optional**— Este atributo opcional indica si el parámetro de entrada es opcional. Si no especifica el **optional** campo, el parámetro de entrada es obligatorio.

En el siguiente ejemplo de plantilla de parámetros se muestra cómo especificar los parámetros de entrada.

```
{
  "myRequiredParameter1": {
     "description": "this parameter is required",
  },
  "myRequiredParameter2": {
     "description": "this parameter is also required",
     "optional": false
  },
  "myOptionalParameter": {
     "description": "this parameter is optional",
     "optional": true
  }
}
```

## Generación de plantillas de parámetros
<a name="parameter-parsing"></a>

HealthOmics genera la plantilla de parámetros analizando la definición del flujo de trabajo para detectar los parámetros de entrada. Si proporciona un archivo de plantilla de parámetros para un flujo de trabajo, los parámetros del archivo anulan los parámetros detectados en la definición del flujo de trabajo.

Existen pequeñas diferencias entre la lógica de análisis de los motores CWL, WDL y Nextflow, como se describe en las siguientes secciones. 

**Topics**
+ [Detección de parámetros para CWL](#parameter-parsing-cwl)
+ [Detección de parámetros para WDL](#parameter-parsing-wdl)
+ [Detección de parámetros para Nextflow](#parameter-parsing-nextflow)

### Detección de parámetros para CWL
<a name="parameter-parsing-cwl"></a>

En el motor de flujo de trabajo CWL, la lógica de análisis hace las siguientes suposiciones:
+ Todos los tipos admitidos que admiten valores NULL se marcan como parámetros de entrada opcionales.
+ Todos los tipos admitidos que no sean nulos se marcan como parámetros de entrada obligatorios.
+ Todos los parámetros con valores predeterminados se marcan como parámetros de entrada opcionales.
+ Las descripciones se extraen de la `label` sección de la definición del `main` flujo de trabajo. Si no `label` se especifica, la descripción estará en blanco (una cadena vacía). 

En las tablas siguientes se muestran ejemplos de interpolación de CWL. Para cada ejemplo, el nombre del parámetro es. `x` Si el parámetro es obligatorio, debe proporcionar un valor para el parámetro. Si el parámetro es opcional, no es necesario que proporcione un valor.

En esta tabla se muestran ejemplos de interpolación de CWL para tipos primitivos.


| Input | Ejemplo de entrada/salida | Obligatorio | 
| --- | --- | --- | 
|  <pre>x:               <br />  type: int</pre>  | 1 o 2 o... | Sí | 
|  <pre>x:               <br />  type: int<br />  default: 2</pre>  | El valor predeterminado es 2. La entrada válida es 1 o 2 o... | No | 
|  <pre>x:               <br />  type: int?</pre>  | La entrada válida es Ninguna o 1 o 2 o... | No | 
|  <pre>x:               <br />  type: int?<br />  default: 2</pre>  | El valor predeterminado es 2. La entrada válida es Ninguna o 1 o 2 o... | No | 

La siguiente tabla muestra ejemplos de interpolación de CWL para tipos complejos. Un tipo complejo es una colección de tipos primitivos.


| Input | Ejemplo de entrada/salida | Obligatorio | 
| --- | --- | --- | 
|  <pre>x:               <br />  type: array<br />  items: int</pre>  | [] o [1,2,3]  | Sí | 
|  <pre>x:               <br />  type: array?<br />  items: int</pre>  | Ninguno o [] o [1,2,3]  | No | 
|  <pre>x:               <br />  type: array<br />  items: int?</pre>  |  [] o [Ninguno, 3, Ninguno]  | Sí | 
|  <pre>x:               <br />  type: array?<br />  items: int?</pre>  |  [Ninguno] o Ninguno o [1,2,3] o [Ninguno, 3] pero no []  | No | 

### Detección de parámetros para WDL
<a name="parameter-parsing-wdl"></a>

En el motor de flujo de trabajo de la WDL, la lógica de análisis hace las siguientes suposiciones:
+ Todos los tipos admitidos que admiten valores NULL se marcan como parámetros de entrada opcionales. 
+ Para los tipos admitidos que no admiten valores nulos:
  + Cualquier variable de entrada con asignación de literales o expresiones se marca como parámetro opcional. Por ejemplo:

    ```
     Int x = 2 
    Float f0 = 1.0 + f1
    ```
  + Si no se ha asignado ningún valor o expresión a los parámetros de entrada, se marcarán como parámetros obligatorios. 
+ Las descripciones se `parameter_meta` extraen de la definición del `main` flujo de trabajo. Si no `parameter_meta` se especifica, la descripción aparecerá en blanco (una cadena vacía). Para obtener más información, consulte la especificación WDL para los [metadatos de los parámetros](https://github.com/openwdl/wdl/blob/wdl-1.2/SPEC.md#metadata-sections).

En las tablas siguientes se muestran ejemplos de interpolación de la WDL. Para cada ejemplo, el nombre del parámetro es. `x` Si el parámetro es obligatorio, debe proporcionar un valor para el parámetro. Si el parámetro es opcional, no es necesario que proporcione un valor.

En esta tabla se muestran ejemplos de interpolación de WDL para tipos primitivos.


| Input | Ejemplo de entrada/salida | Obligatorio | 
| --- | --- | --- | 
| Int x | 1 o 2 o... | Sí | 
| Int x = 2 | 2 | No | 
| Int x = 1\$12 | 3 | No | 
| Int x = y\$1z | y\$1z | No | 
| ¿Int? x | Ninguno o 1 o 2 o... | Sí | 
| ¿Int? x = 2 | Ninguno o 2 | No | 
| ¿Int? x = 1\$12 | Ninguno o 3 | No | 
| ¿Int? x = y\$1z | Ninguno o y\$1z | No | 

La siguiente tabla muestra ejemplos de interpolación de WDL para tipos complejos. Un tipo complejo es un conjunto de tipos primitivos. 


| Input | Ejemplo de entrada/salida | Obligatorio | 
| --- | --- | --- | 
| Array [Int] x | [1,2,3] o [] | Sí | 
| Matriz [Int] \$1 x | [1], pero no [] | Sí | 
| ¿Matriz [Int]? x | Ninguno o [] o [1,2,3] | No | 
| Matriz [Int?] x | [] o [Ninguno, 3, Ninguno] | Sí | 
| Matriz [Int?] =? x | [Ninguno] o Ninguno o [1,2,3] o [Ninguno, 3] pero no [] | No | 
| Ejemplo de estructura \$1String a, Int y\$1 más adelante en las entradas: Sample mySample  |  <pre>String a = mySample.a<br />   Int y = mySample.y</pre>  | Sí | 
| Ejemplo de estructura \$1String a, Int y\$1 más adelante en las entradas: ¿Ejemplo? ¿Mi muestra |  <pre>if (defined(mySample)) { <br />     String a = mySample.a<br />     Int y = mySample.y<br />   } </pre>  | No | 

### Detección de parámetros para Nextflow
<a name="parameter-parsing-nextflow"></a>

En el caso de Nextflow, HealthOmics genera la plantilla de parámetros analizando el archivo. `nextflow_schema.json` Si la definición del flujo de trabajo no incluye un archivo de esquema, HealthOmics analiza el archivo de definición del flujo de trabajo principal.

**Topics**
+ [Analizar el archivo de esquema](#parameter-parsing-nextflow-schema)
+ [Analizando el archivo principal](#parameter-parsing-nextflow-main)
+ [Parámetros anidados](#parameter-parsing-nextflow-nested)
+ [Ejemplos de interpolación de Nextflow](#parameter-parsing-nextflow-examples)

#### Analizar el archivo de esquema
<a name="parameter-parsing-nextflow-schema"></a>

Para que el análisis funcione correctamente, asegúrese de que el archivo de esquema cumpla los siguientes requisitos:
+ El archivo de esquema recibe un nombre `nextflow_schema.json` y se encuentra en el mismo directorio que el archivo de flujo de trabajo principal.
+ El archivo de esquema es un JSON válido, tal como se define en cualquiera de los siguientes esquemas:
  + [esquema json. org/draft/2020-12/schema](https://json-schema.org/draft/2020-12/schema).
  + [esquema json. org/draft-07/schema](https://json-schema.org/draft-07/schema).

HealthOmics analiza el `nextflow_schema.json` archivo para generar la plantilla de parámetros:
+ Extrae todo **properties** lo que está definido en el esquema.
+ Incluye la propiedad **description** si está disponible para la propiedad.
+ Identifica si cada parámetro es opcional u obligatorio, en función del **required** campo de la propiedad.

El siguiente ejemplo muestra un archivo de definición y el archivo de parámetros generado.

```
{
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "type": "object",
    "$defs": {
        "input_options": {
            "title": "Input options",
            "type": "object",
            "required": ["input_file"],
            "properties": {
                "input_file": {
                    "type": "string",
                    "format": "file-path",
                    "pattern": "^s3://[a-z0-9.-]{3,63}(?:/\\S*)?$",
                    "description": "description for input_file"
                },
                "input_num": {
                    "type": "integer",
                    "default": 42,
                    "description": "description for input_num"
                }
            }
        },
        "output_options": {
            "title": "Output options",
            "type": "object",
            "required": ["output_dir"],
            "properties": {
                "output_dir": {
                    "type": "string",
                    "format": "file-path",
                    "description": "description for output_dir",
                }
            }
        }
    },
    "properties": {
        "ungrouped_input_bool": {
            "type": "boolean",
            "default": true
        }
    },
    "required": ["ungrouped_input_bool"],
    "allOf": [
        { "$ref": "#/$defs/input_options" },
        { "$ref": "#/$defs/output_options" }
    ]
}
```

La plantilla de parámetros generada:

```
{
    "input_file": {
        "description": "description for input_file",
        "optional": False
    },
    "input_num": {
        "description": "description for input_num",
        "optional": True
    },
    "output_dir": {
        "description": "description for output_dir",
        "optional": False
    },
    "ungrouped_input_bool": {
        "description": None,
        "optional": False
    }
}
```

#### Analizando el archivo principal
<a name="parameter-parsing-nextflow-main"></a>

Si la definición del flujo de trabajo no incluye un `nextflow_schema.json` archivo, HealthOmics analiza el archivo de definición del flujo de trabajo principal.

HealthOmics analiza las `params` expresiones que se encuentran en el archivo principal de definición del flujo de trabajo y en el `nextflow.config` archivo. Todas `params` las que tengan valores predeterminados se marcan como opcionales.

Para que el análisis funcione correctamente, tenga en cuenta los siguientes requisitos:
+ HealthOmics analiza solo el archivo de definición del flujo de trabajo principal. Para garantizar que se capturen todos los parámetros, le recomendamos que los conecte todos los **params** submódulos y flujos de trabajo importados.
+ El archivo de configuración es opcional. Si define uno, asígnele un nombre `nextflow.config` y colóquelo en el mismo directorio que el archivo de definición del flujo de trabajo principal.

El siguiente ejemplo muestra un archivo de definición y la plantilla de parámetros generada.

```
params.input_file = "default.txt"
params.threads = 4
params.memory = "8GB"

workflow {
    if (params.version) {
        println "Using version: ${params.version}"
    }
}
```

La plantilla de parámetros generada:

```
{
    "input_file": {
        "description": None,
        "optional": True
    },
    "threads": {
        "description": None,
        "optional": True
    },
    "memory": {
        "description": None,
        "optional": True
    },
    "version": {
        "description": None,
        "optional": False
    }
}
```

Para los valores predeterminados que se definen en nextflow.config, HealthOmics recopila `params` las asignaciones y los parámetros declarados en ellos`params {}`, como se muestra en el siguiente ejemplo. En las sentencias de asignación, `params` debe aparecer en el lado izquierdo de la sentencia.

```
params.alpha = "alpha"
params.beta = "beta"

params {
    gamma = "gamma"
    delta = "delta"
}

env {
   // ignored, as this assignment isn't in the params block
   VERSION = "TEST"  
}

// ignored, as params is not on the left side
interpolated_image = "${params.cli_image}"
```

La plantilla de parámetros generada:

```
{
    // other params in your main workflow defintion
    "alpha": {
        "description": None,
        "optional": True
    },
    "beta": {
        "description": None,
        "optional": True
    },
    "gamma": {
        "description": None,
        "optional": True
    },
    "delta": {
        "description": None,
        "optional": True
    }
}
```

#### Parámetros anidados
<a name="parameter-parsing-nextflow-nested"></a>

Ambos `nextflow.config` permiten `nextflow_schema.json` parámetros anidados. Sin embargo, la plantilla de HealthOmics parámetros solo requiere los parámetros de nivel superior. Si su flujo de trabajo utiliza un parámetro anidado, debe proporcionar un objeto JSON como entrada para ese parámetro.

##### Parámetros anidados en archivos de esquema
<a name="parameter-parsing-schema-nested"></a>

HealthOmics omite los anidados **params** al analizar un archivo. `nextflow_schema.json` Por ejemplo, si define el siguiente archivo: `nextflow_schema.json`

```
{
    "properties": {
        "input": {
            "properties": {
                "input_file": { ... },
                "input_num": { ... }
            }
        },
        "input_bool": { ... }
    }
}
```

HealthOmics ignora `input_file` y `input_num` cuando genera la plantilla de parámetros:

```
{
    "input": {
        "description": None,
        "optional": True
    },
    "input_bool": {
        "description": None,
        "optional": True
    }
}
```

Al ejecutar este flujo de trabajo, HealthOmics espera un `input.json` archivo similar al siguiente:

```
{
   "input": {
       "input_file": "s3://bucket/obj",
       "input_num": 2
   },
   "input_bool": false
}
```

##### Parámetros anidados en los archivos de configuración
<a name="parameter-parsing-config-nested"></a>

HealthOmics no recopila los anidados **params** en un `nextflow.config` archivo y los omite durante el análisis. Por ejemplo, si define el siguiente archivo: `nextflow.config`

```
params.alpha = "alpha"
  params.nested.beta = "beta"
  
  params {
      gamma = "gamma"
      group {
          delta = "delta"
      }
  }
```

HealthOmics ignora `params.nested.beta` y `params.group.delta` cuando genera la plantilla de parámetros:

```
{
    "alpha": {
        "description": None,
        "optional": True
    },
    "gamma": {
        "description": None,
        "optional": True
    }
}
```

#### Ejemplos de interpolación de Nextflow
<a name="parameter-parsing-nextflow-examples"></a>

La siguiente tabla muestra ejemplos de interpolación de Nextflow para los parámetros del archivo principal.


| Parámetros | Obligatorio | 
| --- | --- | 
| params.input\$1file | Sí | 
| params.input\$1file = "s3://bucket/data.json» | No | 
| params.nested.input\$1file | N/A | 
| params.nested.input\$1file = "s3://bucket/data.json» | N/A | 

La siguiente tabla muestra ejemplos de interpolación de Nextflow para los parámetros del archivo. `nextflow.config`


| Parámetros | Obligatorio | 
| --- | --- | 
|  <pre>params.input_file = "s3://bucket/data.json"</pre>  | No | 
|  <pre>params {<br />   input_file = "s3://bucket/data.json"<br />}</pre>  | No | 
|  <pre>params {<br />   nested {<br />     input_file = "s3://bucket/data.json"    <br />   }<br />}</pre>  | N/A | 
|  <pre>input_file = params.input_file</pre>  | N/A |