docs: def blast_representative_sequence_to_pdb(self, seq_ident_cutoff=0, evalue=0.0001, display_link=False,
                                               outdir=None, force_rerun=False):
          """BLAST the representative protein sequence to the PDB. Saves a raw BLAST result file (XML file).
  
          Args:
              seq_ident_cutoff (float, optional): Cutoff results based on percent coverage (in decimal form)
              evalue (float, optional): Cutoff for the E-value - filters for significant hits. 0.001 is liberal,
                  0.0001 is stringent (default).
              display_link (bool, optional): Set to True if links to the HTML results should be displayed
              outdir (str): Path to output directory of downloaded XML files, must be set if protein directory
                  was not initialized
              force_rerun (bool, optional): If existing BLAST results should not be used, set to True. Default is False.
  
          Returns:
              list: List of new ``PDBProp`` objects added to the ``structures`` attribute
  
          """
          # Check if a representative sequence was set
          if not self.representative_sequence:
              log.warning('{}: no representative sequence set, cannot BLAST'.format(self.id))
              return None
  
          # Also need to check if a sequence has been stored
          if not self.representative_sequence.seq:
              log.warning('{}: no representative sequence loaded, cannot BLAST'.format(self.id))
              return None
  
          # BLAST the sequence to the PDB
          blast_results = self.representative_sequence.blast_pdb(seq_ident_cutoff=seq_ident_cutoff,
                                                                 evalue=evalue,
                                                                 display_link=display_link,
                                                                 outdir=outdir,
                                                                 force_rerun=force_rerun)
  
          new_pdbs = []
  
          # Add BLAST results to the list of structures
          if blast_results:
  
              # Filter for new BLASTed PDBs
              pdbs = [x['hit_pdb'].lower() for x in blast_results]
              new_pdbs = [y for y in pdbs if not self.structures.has_id(y)]
              if new_pdbs:
                  log.debug('{}: adding {} PDBs from BLAST results'.format(self.id, len(new_pdbs)))
              else:
                  already_have = [y for y in pdbs if self.structures.has_id(y)]
                  log.debug('{}: PDBs already contained in structures list'.format(';'.join(already_have)))
              blast_results = [z for z in blast_results if z['hit_pdb'].lower() in new_pdbs]
  
              for blast_result in blast_results:
                  pdb = blast_result['hit_pdb'].lower()
                  chains = blast_result['hit_pdb_chains']
  
                  for chain in chains:
                      # load_pdb will append this protein to the list of structures
                      new_pdb = self.load_pdb(pdb_id=pdb, mapped_chains=chain)
                      new_pdb.add_chain_ids(chain)
                      new_chain = new_pdb.chains.get_by_id(chain)
  
                      # Store BLAST results within the chain
                      new_chain.blast_results = blast_result
  
          return new_pdbs