Repository: Qiskit/qiskit

Issue:
Individual acquires are created in Qobj to Instruction converter when joined acquires should be
<!-- ⚠️ If you do not respect this template, your issue will be closed -->
<!-- ⚠️ Make sure to browse the opened and closed issues -->

### Information

- **Qiskit Terra version**:
- **Python version**:
- **Operating system**:

### What is the current behaviour?
When a marshmallow acquire `PulseQobjInstruction` is converted to a pulse schedule `AcquireInstruction`, an individual `AcquireInstruction` is being created for each qubit, memory_slot pair.

See:
https://github.com/Qiskit/qiskit-terra/blob/b155373a30c5c1d6550ffb7df9c6a4d660e6dd62/qiskit/qobj/converters/pulse_instruction.py#L428
### Steps to reproduce the problem
Attempt to convert this acquire command

```python
PulseQobjInstruction(duration=1200, memory_slot=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], name='acquire', qubits=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], t0=0)
```


### What is the expected behavior?
A single `AcquireInstruction` should be created for all of the qubits involved with the acquire.





Discussion:

Resolving patch:
diff --git a/qiskit/qobj/converters/pulse_instruction.py b/qiskit/qobj/converters/pulse_instruction.py
--- a/qiskit/qobj/converters/pulse_instruction.py
+++ b/qiskit/qobj/converters/pulse_instruction.py
@@ -16,6 +16,7 @@
 
 import re
 import math
+import warnings
 
 from sympy.parsing.sympy_parser import (parse_expr, standard_transformations,
                                         implicit_multiplication_application,
@@ -389,44 +390,43 @@ def convert_acquire(self, instruction):
         t0 = instruction.t0
         duration = instruction.duration
         qubits = instruction.qubits
-        discriminators = (instruction.discriminators
-                          if hasattr(instruction, 'discriminators') else None)
+        qubit_channels = [channels.AcquireChannel(qubit, buffer=self.buffer) for qubit in qubits]
 
-        kernels = (instruction.kernels
-                   if hasattr(instruction, 'kernels') else None)
+        mem_slots = [channels.MemorySlot(instruction.memory_slot[i]) for i in range(len(qubits))]
 
-        mem_slots = instruction.memory_slot
-        reg_slots = (instruction.register_slot
-                     if hasattr(instruction, 'register_slot') else None)
+        if hasattr(instruction, 'register_slot'):
+            register_slots = [channels.RegisterSlot(instruction.register_slot[i])
+                              for i in range(len(qubits))]
+        else:
+            register_slots = None
 
+        discriminators = (instruction.discriminators
+                          if hasattr(instruction, 'discriminators') else None)
         if not isinstance(discriminators, list):
-            discriminators = [discriminators for _ in range(len(qubits))]
+            discriminators = [discriminators]
+        if any(discriminators[i] != discriminators[0] for i in range(len(discriminators))):
+            warnings.warn("Can currently only support one discriminator per acquire. Defaulting "
+                          "to first discriminator entry.")
+        discriminator = discriminators[0]
+        if discriminator:
+            discriminator = commands.Discriminator(name=discriminators[0].name,
+                                                   params=discriminators[0].params)
 
+        kernels = (instruction.kernels
+                   if hasattr(instruction, 'kernels') else None)
         if not isinstance(kernels, list):
-            kernels = [kernels for _ in range(len(qubits))]
-
+            kernels = [kernels]
+        if any(kernels[0] != kernels[i] for i in range(len(kernels))):
+            warnings.warn("Can currently only support one kernel per acquire. Defaulting to first "
+                          "kernel entry.")
+        kernel = kernels[0]
+        if kernel:
+            kernel = commands.Kernel(name=kernels[0].name, params=kernels[0].params)
+
+        cmd = commands.Acquire(duration, discriminator=discriminator, kernel=kernel)
         schedule = Schedule()
-
-        for i, qubit in enumerate(qubits):
-            kernel = kernels[i]
-            if kernel:
-                kernel = commands.Kernel(name=kernel.name,
-                                         params=kernel.params)
-
-            discriminator = discriminators[i]
-            if discriminator:
-                discriminator = commands.Discriminator(name=discriminator.name,
-                                                       params=discriminator.params)
-
-            channel = channels.AcquireChannel(qubit, buffer=self.buffer)
-            if reg_slots:
-                register_slot = channels.RegisterSlot(reg_slots[i])
-            else:
-                register_slot = None
-            memory_slot = channels.MemorySlot(mem_slots[i])
-
-            cmd = commands.Acquire(duration, discriminator=discriminator, kernel=kernel)
-            schedule |= commands.AcquireInstruction(cmd, channel, memory_slot, register_slot) << t0
+        schedule |= commands.AcquireInstruction(cmd, qubit_channels, mem_slots,
+                                                register_slots) << t0
 
         return schedule
 


Test patch:
diff --git a/test/python/qobj/test_pulse_converter.py b/test/python/qobj/test_pulse_converter.py
--- a/test/python/qobj/test_pulse_converter.py
+++ b/test/python/qobj/test_pulse_converter.py
@@ -147,13 +147,16 @@ def setUp(self):
 
         self.device = DeviceSpecification(
             qubits=[
-                Qubit(0, DriveChannel(0), MeasureChannel(0), AcquireChannel(0))
+                Qubit(0, DriveChannel(0), MeasureChannel(0), AcquireChannel(0)),
+                Qubit(1, DriveChannel(1), MeasureChannel(1), AcquireChannel(1)),
             ],
             registers=[
-                RegisterSlot(0)
+                RegisterSlot(0),
+                RegisterSlot(1)
             ],
             mem_slots=[
-                MemorySlot(0)
+                MemorySlot(0),
+                MemorySlot(1)
             ]
         )
 
@@ -196,8 +199,8 @@ def test_acquire(self):
                       Kernel(name='test_kern', params={'test_params': 'test'}))
         instruction = cmd(self.device.q, self.device.mem, self.device.c)
 
-        qobj = PulseQobjInstruction(name='acquire', t0=0, duration=10, qubits=[0],
-                                    memory_slot=[0], register_slot=[0],
+        qobj = PulseQobjInstruction(name='acquire', t0=0, duration=10, qubits=[0, 1],
+                                    memory_slot=[0, 1], register_slot=[0, 1],
                                     kernels=[QobjMeasurementOption(
                                         name='test_kern', params={'test_params': 'test'})],
                                     discriminators=[QobjMeasurementOption(