/// <summary>
        /// Saves the term model. Prefix is clean filename prefix without spacing character
        /// </summary>
        /// <param name="termModel">The term model.</param>
        /// <param name="prefix">The prefix.</param>
        public void saveTermModel(termExploreModel termModel, string prefix = "")
        {
            string   filepath = projectFolderStructure[lexiconConstructorProjectFolder.metadata].path + "\\" + prefix + termModel.filename(".xml");
            FileInfo fi       = filepath.getWritableFile(getWritableFileMode.overwrite);

            objectSerialization.saveObjectToXML(termModel, fi.FullName);
        }
        public void addSynonymsAndConceptLinks(termExploreModel termModel, bool saveModel = false)
        {
            // <----------- ADDING SYNONYMS ----------- >

            var lemmas = manager.getLemma(termModel.lemmaForm);

            var lemmasyns = manager.getLemmas(termModel.synonyms);

            builderForLog linkLog = new builderForLog();

            linkLog.open("Creating synonym-2-lemma links");

            termModel.links_synonym = 0;
            foreach (ITermLemma lemma in lemmas)
            {
                foreach (ITermLemma lemsyn in lemmasyns)
                {
                    bool added = false;
                    if (!lemma.relatedTo.Contains(lemsyn))
                    {
                        if (!lemma.relatedFrom.Contains(lemsyn))
                        {
                            lemma.relatedTo.Add(lemsyn);

                            added = true;
                        }
                    }
                    if (added)
                    {
                        termModel.links_synonym++;
                        linkLog.AppendLine("[" + termModel.links_synonym.ToString("D5") + "] " + lemma.name + " -> " + lemsyn.name);
                    }
                    else
                    {
                        linkLog.AppendLine("[Link exists] " + lemma.name + " -> " + lemsyn.name);
                    }
                }
            }
            linkLog.close();

            linkLog.open("Creating concept 2 lemma links");
            // <----------- ADDING SYNSETS
            List <Concept> concepts = new List <Concept>();
            Concept        conHead  = null;

            termModel.links_lemmaConcept = 0;
            foreach (string code in termModel.wordnetPrimarySymsets)
            {
                if (code.isCleanWord())
                {
                    aceLog.log("wrong symset code -- [" + code + "]  -- ignored!");
                    continue;
                }
                Concept con   = manager.getConcept(code, true, "WordNet Code");
                bool    added = false;
                foreach (TermLemma lemma in lemmas)
                {
                    if (!con.lemmas.Contains(lemma))
                    {
                        con.lemmas.Add(lemma);
                        added = true;
                    }
                    if (added)
                    {
                        termModel.links_lemmaConcept++;
                        linkLog.AppendLine("[" + termModel.links_lemmaConcept.ToString("D5") + "] " + con.name + " -> " + lemma.name);
                    }
                    else
                    {
                        linkLog.AppendLine("[Link exists] " + con.name + " -> " + lemma.name);
                    }
                }

                concepts.Add(con);
                conHead = con;
            }
            linkLog.close();

            linkLog.open("Creating concept 2 concept links");
            // <--------------------------- linking SYNSET concepts
            termModel.links_conceptConcept = 0;
            foreach (Concept con in concepts)
            {
                foreach (Concept con2 in concepts)
                {
                    bool added = false;
                    if (!con2.relatedTo.Contains(con))
                    {
                        if (!con2.relatedFrom.Contains(con))
                        {
                            var sharedLemmas = con2.lemmas.Where(x => con.lemmas.Contains(x));
                            if (sharedLemmas.Count() > 0)
                            {
                                con2.relatedTo.Add(con);
                                added = true;
                            }
                        }
                    }
                    if (added)
                    {
                        termModel.links_conceptConcept++;
                        linkLog.AppendLine("[" + termModel.links_conceptConcept.ToString("D5") + "] " + con2.name + " -> " + con.name);
                    }
                    else
                    {
                        linkLog.AppendLine("[Link exists] " + con2.name + " -> " + con.name);
                    }
                }
            }
            linkLog.close();

            manager.lexiconContext.SaveChanges();
            string pth = projectFolderStructure[lexiconConstructorProjectFolder.links].pathFor(termModel.filename(".txt"));

            linkLog.ToString().saveStringToFile(pth, getWritableFileMode.overwrite);

            if (saveModel)
            {
                saveTermModel(termModel);
            }
        }