docs: def convert_inputfiles(cls,
                             folder=None,
                             inputfile=None,
                             session=None,
                             lod_threshold=None,
                             qtls_file='qtls.csv',
                             matrix_file='qtls_matrix.csv',
                             map_file='map.csv'):
          """ Convert the input files present in the given folder or
          inputfile.
          This method creates the matrix representation of the QTLs
          results providing for each marker position the LOD value found
          for each trait as well as a representation of the genetic map
          used in the experiment.
          The genetic map should be cleared of any markers added by the
          QTL mapping software.
  
          :kwarg folder: the path to the folder containing the files to
              check. This folder may contain sub-folders.
          :kwarg inputfile: the path to the input file to use
          :kwarg session: the session identifier used to identify which
              session to process
          :kwarg lod_threshold: the LOD threshold to apply to determine if
              a QTL is significant or not
          :kwarg qtls_file: a csv file containing the list of all the
              significant QTLs found in the analysis.
              The matrix is of type:
                 trait, linkage group, position, Marker, LOD other columns
          :kwarg matrix_file: a csv file containing a matrix representation
              of the QTL data. This matrix is of type:
                 marker, linkage group, position, trait1 lod, trait2, lod
          :kwarg map_file: a csv file containing the genetic map used
              in this experiment. The map is of structure:
                 marker, linkage group, position
  
          """
          if folder is None and inputfile is None:
              raise MQ2Exception('You must specify either a folder or an '
                                 'input file')
  
          if folder is not None:  # pragma: no cover
              if not os.path.isdir(folder):
                  raise MQ2Exception('The specified folder is actually '
                                     'not a folder')
              else:
                  inputfiles = cls.get_files(folder)
  
          if inputfile is not None:  # pragma: no cover
              if os.path.isdir(inputfile):
                  raise MQ2Exception('The specified input file is actually '
                                     'a folder')
              else:
                  inputfiles = [inputfile]
  
          sessions = cls.get_session_identifiers(
              folder=folder, inputfile=inputfile)
  
          if session is None:
              raise MQ2NoSessionException(
                  'The Excel plugin requires a sheet identifier to '
                  'identify the sheet of the workbook to process. '
                  'Sheets are: %s' % ','.join(sessions))
          elif str(session) not in sessions:
              raise MQ2NoSuchSessionException(
                  'The Excel sheet provided (%s) could not be found in the '
                  'workbook. '
                  'Sheets are: %s' % (session, ','.join(sessions)))
  
          if len(inputfiles) > 1:  # pragma: no cover
              raise MQ2Exception(
                  'This plugin can only process one file at a time')
  
          try:
              lod_threshold = float(lod_threshold)
          except ValueError:
              raise MQ2Exception('LOD threshold should be a number')
  
          inputfile = inputfiles[0]
  
          # QTL matrix and QTL files
          qtls = []
          matrix = read_excel_file(inputfile, sheet_name=session)
          qtls.extend(get_qtls_from_rqtl_data(matrix, lod_threshold))
          # format QTLs and write down the selection
          write_matrix(qtls_file, qtls)
  
          # Write down the QTL matrix
          write_matrix(matrix_file, matrix)
  
          # Map matrix
          map_matrix = get_map_matrix(inputfile, session)
          write_matrix(map_file, map_matrix)