Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# File template parameter untuk HealthOmics alur kerja
<a name="parameter-templates"></a>

Template parameter menentukan parameter input untuk alur kerja. Anda dapat menentukan parameter input untuk membuat alur kerja Anda lebih fleksibel dan serbaguna. Misalnya, Anda dapat menentukan parameter untuk lokasi Amazon S3 dari file genom referensi. Template parameter dapat disediakan melalui layanan repositori berbasis Git atau drive lokal Anda. Pengguna kemudian dapat menjalankan alur kerja menggunakan berbagai set data. 

Anda dapat membuat template parameter untuk alur kerja Anda, atau HealthOmics dapat menghasilkan template parameter untuk Anda.

Template parameter adalah file JSON. Dalam file, setiap parameter input adalah objek bernama yang harus cocok dengan nama input alur kerja. Saat Anda memulai proses, jika Anda tidak memberikan nilai untuk semua parameter yang diperlukan, proses gagal.

Objek parameter masukan mencakup atribut berikut:
+ **description**— Atribut wajib ini adalah string yang ditampilkan konsol di halaman **Mulai jalankan**. Deskripsi ini juga dipertahankan sebagai run metadata.
+ **optional**— Atribut opsional ini menunjukkan apakah parameter input adalah opsional. Jika Anda tidak menentukan **optional** bidang, parameter input diperlukan.

Contoh template parameter berikut menunjukkan bagaimana menentukan parameter masukan.

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

## Menghasilkan templat parameter
<a name="parameter-parsing"></a>

HealthOmics menghasilkan template parameter dengan mengurai definisi alur kerja untuk mendeteksi parameter input. Jika Anda menyediakan file template parameter untuk alur kerja, parameter dalam file Anda akan mengganti parameter yang terdeteksi dalam definisi alur kerja.

Ada sedikit perbedaan antara logika parsing mesin CWL, WDL, dan Nextflow, seperti yang dijelaskan di bagian berikut. 

**Topics**
+ [Deteksi parameter untuk CWL](#parameter-parsing-cwl)
+ [Deteksi parameter untuk WDL](#parameter-parsing-wdl)
+ [Deteksi parameter untuk Nextflow](#parameter-parsing-nextflow)

### Deteksi parameter untuk CWL
<a name="parameter-parsing-cwl"></a>

Di mesin alur kerja CWL, logika parsing membuat asumsi berikut:
+ Tipe yang didukung nullable ditandai sebagai parameter input opsional.
+ Tipe yang didukung non-null ditandai sebagai parameter input yang diperlukan.
+ Setiap parameter dengan nilai default ditandai sebagai parameter input opsional.
+ Deskripsi diekstraksi dari `label` bagian dari definisi `main` alur kerja. Jika tidak `label` ditentukan, deskripsi akan kosong (string kosong). 

Tabel berikut menunjukkan contoh interpolasi CWL. Untuk setiap contoh, nama parameternya adalah`x`. Jika parameter diperlukan, Anda harus memberikan nilai untuk parameter. Jika parameternya opsional, Anda tidak perlu memberikan nilai.

Tabel ini menunjukkan contoh interpolasi CWL untuk tipe primitif.


| Input | Contoh input/output | Wajib | 
| --- | --- | --- | 
|  <pre>x:               <br />  type: int</pre>  | 1 atau 2 atau... | Ya | 
|  <pre>x:               <br />  type: int<br />  default: 2</pre>  | Nilai default adalah 2. Masukan yang valid adalah 1 atau 2 atau... | Tidak | 
|  <pre>x:               <br />  type: int?</pre>  | Masukan yang valid adalah None atau 1 atau 2 atau... | Tidak | 
|  <pre>x:               <br />  type: int?<br />  default: 2</pre>  | Nilai default adalah 2. Masukan yang valid adalah None atau 1 atau 2 atau... | Tidak | 

Tabel berikut menunjukkan contoh interpolasi CWL untuk tipe kompleks. Tipe kompleks adalah kumpulan tipe primitif.


| Input | Contoh input/output | Wajib | 
| --- | --- | --- | 
|  <pre>x:               <br />  type: array<br />  items: int</pre>  | [] atau [1,2,3]  | Ya | 
|  <pre>x:               <br />  type: array?<br />  items: int</pre>  | Tidak ada atau [] atau [1,2,3]  | Tidak | 
|  <pre>x:               <br />  type: array<br />  items: int?</pre>  |  [] atau [Tidak ada, 3, tidak ada]  | Ya | 
|  <pre>x:               <br />  type: array?<br />  items: int?</pre>  |  [Tidak] atau Tidak ada atau [1,2,3] atau [Tidak ada, 3] tetapi tidak []  | Tidak | 

### Deteksi parameter untuk WDL
<a name="parameter-parsing-wdl"></a>

Di mesin alur kerja WDL, logika parsing membuat asumsi berikut:
+ Tipe yang didukung nullable ditandai sebagai parameter input opsional. 
+ Untuk tipe yang didukung yang tidak dapat dibatalkan:
  + Setiap variabel input dengan penetapan literal atau ekspresi ditandai sebagai parameter opsional. Misalnya:

    ```
     Int x = 2 
    Float f0 = 1.0 + f1
    ```
  + Jika tidak ada nilai atau ekspresi yang ditetapkan ke parameter input, mereka akan ditandai sebagai parameter yang diperlukan. 
+ Deskripsi diekstraksi dari `parameter_meta` dalam definisi `main` alur kerja. Jika tidak `parameter_meta` ditentukan, deskripsi akan kosong (string kosong). Untuk informasi lebih lanjut, lihat spesifikasi WDL untuk metadata [Parameter](https://github.com/openwdl/wdl/blob/wdl-1.2/SPEC.md#metadata-sections).

Tabel berikut menunjukkan contoh interpolasi WDL. Untuk setiap contoh, nama parameternya adalah`x`. Jika parameter diperlukan, Anda harus memberikan nilai untuk parameter. Jika parameternya opsional, Anda tidak perlu memberikan nilai.

Tabel ini menunjukkan contoh interpolasi WDL untuk tipe primitif.


| Input | Contoh input/output | Wajib | 
| --- | --- | --- | 
| Int x | 1 atau 2 atau... | Ya | 
| Int x = 2 | 2 | Tidak | 
| Int x = 1\$12 | 3 | Tidak | 
| Int x = y\$1z | y\$1z | Tidak | 
| Int? x | Tidak ada atau 1 atau 2 atau... | Ya | 
| Int? x = 2 | Tidak ada atau 2 | Tidak | 
| Int? x = 1\$12 | Tidak ada atau 3 | Tidak | 
| Int? x = y\$1z | Tidak ada atau y\$1z | Tidak | 

Tabel berikut menunjukkan contoh interpolasi WDL untuk tipe kompleks. Tipe kompleks adalah kumpulan tipe primitif. 


| Input | Contoh input/output | Wajib | 
| --- | --- | --- | 
| Array [Int] x | [1,2,3] atau [] | Ya | 
| Array [Int] \$1 x | [1], tetapi tidak [] | Ya | 
| Array [Int]? x | Tidak ada atau [] atau [1,2,3] | Tidak | 
| Array [Int?] x | [] atau [Tidak ada, 3, tidak ada] | Ya | 
| Array [Int?] =? x | [Tidak] atau Tidak ada atau [1,2,3] atau [Tidak ada, 3] tetapi tidak [] | Tidak | 
| Contoh struktur \$1String a, Int y\$1 nanti di input: Contoh MySample  |  <pre>String a = mySample.a<br />   Int y = mySample.y</pre>  | Ya | 
| Contoh struktur \$1String a, Int y\$1 nanti di input: Sampel? MySample |  <pre>if (defined(mySample)) { <br />     String a = mySample.a<br />     Int y = mySample.y<br />   } </pre>  | Tidak | 

### Deteksi parameter untuk Nextflow
<a name="parameter-parsing-nextflow"></a>

Untuk Nextflow, HealthOmics buat template parameter dengan mengurai file. `nextflow_schema.json` Jika definisi alur kerja tidak menyertakan file skema, HealthOmics parsing file definisi alur kerja utama.

**Topics**
+ [Mengurai file skema](#parameter-parsing-nextflow-schema)
+ [Mengurai file utama](#parameter-parsing-nextflow-main)
+ [Parameter bersarang](#parameter-parsing-nextflow-nested)
+ [Contoh interpolasi Nextflow](#parameter-parsing-nextflow-examples)

#### Mengurai file skema
<a name="parameter-parsing-nextflow-schema"></a>

Agar parsing berfungsi dengan benar, pastikan file skema memenuhi persyaratan berikut:
+ File skema diberi nama `nextflow_schema.json` dan terletak di direktori yang sama dengan file alur kerja utama.
+ File skema adalah JSON valid seperti yang didefinisikan dalam salah satu skema berikut:
  + [skema json. org/draft/2020-12/schema](https://json-schema.org/draft/2020-12/schema).
  + [skema json. org/draft-07/schema](https://json-schema.org/draft-07/schema).

HealthOmics `nextflow_schema.json`mem-parsing file untuk menghasilkan template parameter:
+ Ekstrak semua **properties** yang didefinisikan dalam skema.
+ Termasuk properti **description** jika tersedia untuk properti.
+ Mengidentifikasi apakah setiap parameter opsional atau wajib, berdasarkan **required** bidang properti.

Contoh berikut menunjukkan file definisi dan file parameter yang dihasilkan.

```
{
    "$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" }
    ]
}
```

Template parameter yang dihasilkan:

```
{
    "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
    }
}
```

#### Mengurai file utama
<a name="parameter-parsing-nextflow-main"></a>

Jika definisi alur kerja tidak menyertakan `nextflow_schema.json` file, HealthOmics parsing file definisi alur kerja utama.

HealthOmics menganalisis `params` ekspresi yang ditemukan di file definisi alur kerja utama dan dalam file. `nextflow.config` Semua `params` dengan nilai default ditandai sebagai opsional.

Agar parsing berfungsi dengan benar, perhatikan persyaratan berikut:
+ HealthOmics hanya mem-parsing file definisi alur kerja utama. Untuk memastikan semua parameter ditangkap, kami sarankan Anda menghubungkan semua **params** submodul dan alur kerja yang diimpor.
+ File konfigurasi adalah opsional. Jika Anda mendefinisikannya, beri nama `nextflow.config` dan letakkan di direktori yang sama dengan file definisi alur kerja utama.

Contoh berikut menunjukkan file definisi dan template parameter yang dihasilkan.

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

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

Template parameter yang dihasilkan:

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

Untuk nilai default yang didefinisikan dalam nextflow.config, HealthOmics mengumpulkan `params` tugas dan parameter yang dideklarasikan dalam`params {}`, seperti yang ditunjukkan pada contoh berikut. Dalam pernyataan penugasan, `params` harus muncul di sisi kiri pernyataan.

```
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}"
```

Template parameter yang dihasilkan:

```
{
    // 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
    }
}
```

#### Parameter bersarang
<a name="parameter-parsing-nextflow-nested"></a>

Keduanya `nextflow_schema.json` dan `nextflow.config` memungkinkan parameter bersarang. Namun, template HealthOmics parameter hanya membutuhkan parameter tingkat atas. Jika alur kerja Anda menggunakan parameter bersarang, Anda harus menyediakan objek JSON sebagai input untuk parameter tersebut.

##### Parameter bersarang dalam file skema
<a name="parameter-parsing-schema-nested"></a>

HealthOmics melewatkan bersarang **params** saat mengurai file. `nextflow_schema.json` Misalnya, jika Anda mendefinisikan `nextflow_schema.json` file berikut:

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

HealthOmics mengabaikan `input_file` dan `input_num` ketika menghasilkan template parameter:

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

Saat Anda menjalankan alur kerja ini, HealthOmics mengharapkan `input.json` file yang mirip dengan berikut ini:

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

##### Parameter bersarang dalam file konfigurasi
<a name="parameter-parsing-config-nested"></a>

HealthOmics tidak mengumpulkan bersarang **params** dalam `nextflow.config` file, dan melewatkannya selama penguraian. Misalnya, jika Anda mendefinisikan `nextflow.config` file berikut:

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

HealthOmics mengabaikan `params.nested.beta` dan `params.group.delta` ketika menghasilkan template parameter:

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

#### Contoh interpolasi Nextflow
<a name="parameter-parsing-nextflow-examples"></a>

Tabel berikut menunjukkan contoh interpolasi Nextflow untuk params di file utama.


| Parameter | Wajib | 
| --- | --- | 
| params.input\$1file | Ya | 
| params.input\$1file = "s3://bucket/data.json” | Tidak | 
| params.nested.input\$1file | N/A | 
| params.nested.input\$1file = "s3://bucket/data.json” | N/A | 

Tabel berikut menunjukkan contoh interpolasi Nextflow untuk params dalam file. `nextflow.config`


| Parameter | Wajib | 
| --- | --- | 
|  <pre>params.input_file = "s3://bucket/data.json"</pre>  | Tidak | 
|  <pre>params {<br />   input_file = "s3://bucket/data.json"<br />}</pre>  | Tidak | 
|  <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 |