docs: def naiveWordAlignment(tg, utteranceTierName, wordTierName, isleDict,
                         phoneHelperTierName=None,
                         removeOverlappingSegments=False):
      '''
      Performs naive alignment for utterances in a textgrid
      
      Naive alignment gives each segment equal duration.  Word duration is
      determined by the duration of an utterance and the number of phones in
      the word.
      
      By 'utterance' I mean a string of words separated by a space bounded
      in time eg (0.5, 1.5, "he said he likes ketchup").
      
      phoneHelperTierName - creates a tier that is parallel to the word tier.
                            However, the labels are the phones for the word,
                            rather than the word
      removeOverlappingSegments - remove any labeled words or phones that
                                  fall under labeled utterances
      '''
      utteranceTier = tg.tierDict[utteranceTierName]
      
      wordTier = None
      if wordTierName in tg.tierNameList:
          wordTier = tg.tierDict[wordTierName]
      
      # Load in the word tier, if it exists:
      wordEntryList = []
      phoneEntryList = []
      if wordTier is not None:
          if removeOverlappingSegments:
              for startT, stopT, _ in utteranceTier.entryList:
                  wordTier = wordTier.eraseRegion(startT, stopT,
                                                  'truncate', False)
          wordEntryList = wordTier.entryList
  
      # Do the naive alignment
      for startT, stopT, label in utteranceTier.entryList:
          wordList = label.split()
  
          # Get the list of phones in each word
          superPhoneList = []
          numPhones = 0
          i = 0
          while i < len(wordList):
              word = wordList[i]
              try:
                  firstSyllableList = isleDict.lookup(word)[0][0][0]
              except isletool.WordNotInISLE:
                  wordList.pop(i)
                  continue
              phoneList = [phone for syllable in firstSyllableList
                           for phone in syllable]
              superPhoneList.append(phoneList)
              numPhones += len(phoneList)
              i += 1
          
          # Get the naive alignment for words, if alignment doesn't
          # already exist for words
          subWordEntryList = []
          subPhoneEntryList = []
          if wordTier is not None:
              subWordEntryList = wordTier.crop(startT, stopT,
                                               "truncated", False).entryList
          
          if len(subWordEntryList) == 0:
              wordStartT = startT
              phoneDur = (stopT - startT) / float(numPhones)
              for i, word in enumerate(wordList):
                  phoneListTxt = " ".join(superPhoneList[i])
                  wordStartT = wordStartT
                  wordEndT = wordStartT + (phoneDur * len(superPhoneList[i]))
                  subWordEntryList.append((wordStartT, wordEndT, word))
                  subPhoneEntryList.append((wordStartT, wordEndT, phoneListTxt))
                  wordStartT = wordEndT
          
          wordEntryList.extend(subWordEntryList)
          phoneEntryList.extend(subPhoneEntryList)
      
      # Replace or add the word tier
      newWordTier = tgio.IntervalTier(wordTierName,
                                      wordEntryList,
                                      tg.minTimestamp,
                                      tg.maxTimestamp)
      if wordTier is not None:
          tg.replaceTier(wordTierName, newWordTier)
      else:
  
          tg.addTier(newWordTier)
          
      # Add the phone tier
      # This is mainly used as an annotation tier
      if phoneHelperTierName is not None and len(phoneEntryList) > 0:
          newPhoneTier = tgio.IntervalTier(phoneHelperTierName,
                                           phoneEntryList,
                                           tg.minTimestamp,
                                           tg.minTimestamp)
          if phoneHelperTierName in tg.tierNameList:
              tg.replaceTier(phoneHelperTierName, newPhoneTier)
          else:
              tg.addTier(newPhoneTier)
      
      return tg