docs: def build(self):
          """Build single DNA strand along z-axis, starting with P on x-axis"""
          ang_per_res = (2 * numpy.pi) / self.nucleotides_per_turn
          atom_offset_coords = _backbone_properties[self.helix_type]['atoms']
          if self.handedness == 'l':
              handedness = -1
          else:
              handedness = 1
          base_atom_labels = _backbone_properties[self.helix_type]['labels']
          monomers = []
          mol_code_format = _backbone_properties[self.helix_type]['mol_code_format']
          for i, b in enumerate(self.base_sequence):
              nucleotide = Nucleotide(
                  mol_code=mol_code_format.format(b), ampal_parent=self)
              atoms_dict = OrderedDict()
              if (i == (len(self.base_sequence) - 1)) and not self.phos_3_prime:
                  # Do not include phosphate on last nucleotide
                  atom_labels = base_atom_labels[3:] + [_bases[b]['labels'][2]]
                  atom_offsets = {k: v for k, v in zip(
                      atom_labels, atom_offset_coords[3:])}
              else:
                  atom_labels = base_atom_labels + [_bases[b]['labels'][2]]
                  atom_offsets = {k: v for k, v in zip(
                      atom_labels, atom_offset_coords)}
              for atom_label in atom_labels:
                  r, zeta, z_shift = atom_offsets[atom_label]
                  rot_ang = ((i * ang_per_res) + zeta) * handedness
                  z = (self.rise_per_nucleotide * i) + z_shift
                  coords = cylindrical_to_cartesian(
                      radius=r, azimuth=rot_ang, z=z, radians=True)
                  atom = Atom(
                      coordinates=coords, element=atom_label[0],
                      ampal_parent=nucleotide, res_label=atom_label)
                  atoms_dict[atom_label] = atom
              base_ref = _bases[b]['ref_atom']
              rot_adj = _bases[b]['rot_adj']
              base_dict = OrderedDict(
                  zip(_bases[b]['labels'], _bases[b]['atoms']))
              translation, angle, axis, point = find_transformations(
                  base_dict[base_ref], base_dict["C1'"],
                  atoms_dict[base_ref]._vector, atoms_dict["C1'"]._vector)
              q1 = Quaternion.angle_and_axis(angle, axis)
              # Align N9 C1'
              for k, v in base_dict.items():
                  base_dict[k] = q1.rotate_vector(v, point) + translation
              # Rotate to align O4'
              axis = numpy.array(base_dict["C1'"]) - base_dict[base_ref]
              angle = dihedral(base_dict["O4'"], base_dict[base_ref],
                               base_dict["C1'"], atoms_dict["O4'"]) - rot_adj
              q2 = Quaternion.angle_and_axis(angle, axis)
              for k, v in list(base_dict.items()):
                  if k not in atoms_dict:
                      atom = Atom(q2.rotate_vector(v, base_dict[base_ref]),
                                  element=k[0], ampal_parent=nucleotide,
                                  res_label=k)
                      atoms_dict[k] = atom
              nucleotide.atoms = atoms_dict
              monomers.append(nucleotide)
          self._monomers = monomers
          self.relabel_monomers()
          self.relabel_atoms()
          return