Module:SMILES2IUPAC/Functional

-- Module:SMILES2IUPAC/Functional
--
-- Functional-group naming for simple acyclic saturated compounds.
--
-- Supported:
--   alcohols
--   ethers
--   haloalkanes
--   alkyl hypochlorites

local Chain = require('Module:SMILES2IUPAC/Chain')
local Data = require('Module:SMILES2IUPAC/Data')

local p = {}

local halogens = {
	Cl = 'chloro',
	Br = 'bromo',
	F = 'fluoro',
	I = 'iodo'
}

local halogenElements = {
	chloro = true,
	bromo = true,
	fluoro = true,
	iodo = true
}

local function isHalogen(element)
	return halogens[element] ~= nil
end

local function getAtom(graph, index)
	return graph.atoms[index]
end

local function neighbours(graph, atomIndex)
	local result = {}

	for _, bond in ipairs(graph.bonds) do
		if bond.a == atomIndex then
			table.insert(result, bond.b)
		elseif bond.b == atomIndex then
			table.insert(result, bond.a)
		end
	end

	return result
end

local function heavyNeighbours(graph, atomIndex)
	local result = {}

	for _, node in ipairs(neighbours(graph, atomIndex)) do
		if getAtom(graph, node).element ~= 'H' then
			table.insert(result, node)
		end
	end

	return result
end

local function getCarbons(graph)
	local result = {}

	for i, atom in ipairs(graph.atoms) do
		if atom.element == 'C' then
			table.insert(result, i)
		end
	end

	return result
end

local function pathSet(path)
	local result = {}

	for _, node in ipairs(path) do
		result[node] = true
	end

	return result
end

local function inPath(path, node)
	for _, n in ipairs(path) do
		if n == node then
			return true
		end
	end

	return false
end

local function getRoot(n)
	if Data.chainRoot and Data.chainRoot[n] then
		return Data.chainRoot[n]
	end

	if Data.chainExceptions and Data.chainExceptions[n] then
		return Data.chainExceptions[n]
	end

	return nil
end

----------------------------------------------------------------------
-- Find a longest chain containing a required carbon
----------------------------------------------------------------------

local function longestChainContaining(carbons, adj, required)
	local candidates = Chain.findLongestChains(carbons, adj)
	local best = nil

	for _, chain in ipairs(candidates) do
		if inPath(chain, required) then
			if not best or #chain > #best then
				best = chain
			end
		end
	end

	return best
end

----------------------------------------------------------------------
-- Orient a chain so the functional group gets the lowest locant
----------------------------------------------------------------------

local function orientPathForNode(path, node)
	local position = nil

	for i, n in ipairs(path) do
		if n == node then
			position = i
			break
		end
	end

	if not position then
		return path, nil
	end

	local reversePosition = #path - position + 1

	if reversePosition < position then
		local reversed = {}

		for i = #path, 1, -1 do
			table.insert(reversed, path[i])
		end

		return reversed, reversePosition
	end

	return path, position
end

----------------------------------------------------------------------
-- Prefix helpers
----------------------------------------------------------------------

local function multiplierForCount(count)
	if count == 2 then
		return 'di'
	elseif count == 3 then
		return 'tri'
	elseif count == 4 then
		return 'tetra'
	end

	return ''
end

local function buildSubstituentPrefix(name, locants)
	if not locants or #locants == 0 then
		return nil
	end

	table.sort(locants)

	local values = {}

	for _, locant in ipairs(locants) do
		table.insert(values, tostring(locant))
	end

	return table.concat(values, ',')
		.. '-'
		.. multiplierForCount(#locants)
		.. name
end

local function buildSubstituentPrefixList(substituents)
	local names = {}

	for name in pairs(substituents) do
		table.insert(names, name)
	end

	table.sort(names)

	local parts = {}

	for _, name in ipairs(names) do
		local part = buildSubstituentPrefix(
			name,
			substituents[name]
		)

		if part then
			table.insert(parts, part)
		end
	end

	return parts
end

----------------------------------------------------------------------
-- Carbon substituents
----------------------------------------------------------------------

local function collectCarbonSubstituents(graph, path, adj)
	local result = {}
	local pathNodes = pathSet(path)

	for index, carbon in ipairs(path) do
		for _, neighbour in ipairs(adj[carbon] or {}) do
			if not pathNodes[neighbour] then
				if getAtom(graph, neighbour).element == 'C' then
					local subtree = Chain.substituentSubtree(
						adj,
						neighbour,
						pathNodes
					)

					if #subtree == 1 then
						if not result.methyl then
							result.methyl = {}
						end

						table.insert(result.methyl, index)
					end
				end
			end
		end
	end

	return result
end

----------------------------------------------------------------------
-- Halogen substituents
----------------------------------------------------------------------

local function collectHalogenSubstituents(graph, path)
	local result = {}

	for index, carbon in ipairs(path) do
		for _, atomIndex in ipairs(neighbours(graph, carbon)) do
			local atom = getAtom(graph, atomIndex)

			if isHalogen(atom.element) then
				local name = halogens[atom.element]

				if not result[name] then
					result[name] = {}
				end

				table.insert(result[name], index)
			end
		end
	end

	return result
end

local function mergeSubstituents(target, source)
	for name, locants in pairs(source) do
		if not target[name] then
			target[name] = {}
		end

		for _, locant in ipairs(locants) do
			table.insert(target[name], locant)
		end
	end
end

----------------------------------------------------------------------
-- ALCOHOL
----------------------------------------------------------------------

local function nameAlcohol(graph, carbons, adj)
	local oxygen = nil

	for i, atom in ipairs(graph.atoms) do
		if atom.element == 'O' then
			oxygen = i
			break
		end
	end

	if not oxygen then
		return nil
	end

	local oxygenNeighbours = heavyNeighbours(graph, oxygen)

	-- Alcohol: C-O-H
	if #oxygenNeighbours ~= 1 then
		return nil
	end

	local alcoholCarbon = oxygenNeighbours[1]

	if getAtom(graph, alcoholCarbon).element ~= 'C' then
		return nil
	end

	local chain = longestChainContaining(
		carbons,
		adj,
		alcoholCarbon
	)

	if not chain then
		return nil
	end

	chain, alcoholLocant = orientPathForNode(
		chain,
		alcoholCarbon
	)

	local length = #chain
	local root = getRoot(length)

	if not root then
		return nil
	end

	local substituents = collectCarbonSubstituents(
		graph,
		chain,
		adj
	)

	mergeSubstituents(
		substituents,
		collectHalogenSubstituents(
			graph,
			chain
		)
	)

	local parts = buildSubstituentPrefixList(substituents)

	if length == 1 and #parts == 0 then
		return 'methanol'
	end

	if length == 2 and #parts == 0 then
		return 'ethanol'
	end

	local name = root
		.. 'an-'
		.. tostring(alcoholLocant)
		.. '-ol'

	if #parts > 0 then
		name = table.concat(parts, '-') .. name
	end

	return name
end

----------------------------------------------------------------------
-- HALOALKANE
----------------------------------------------------------------------

local function nameHaloalkane(graph, carbons, adj)
	local hasHalogen = false

	for _, atom in ipairs(graph.atoms) do
		if isHalogen(atom.element) then
			hasHalogen = true
		elseif atom.element ~= 'C'
			and atom.element ~= 'H'
		then
			return nil
		end
	end

	if not hasHalogen then
		return nil
	end

	local halogenCarbons = {}

	for i, atom in ipairs(graph.atoms) do
		if isHalogen(atom.element) then
			for _, neighbour in ipairs(neighbours(graph, i)) do
				if getAtom(graph, neighbour).element == 'C' then
					halogenCarbons[neighbour] = true
				end
			end
		end
	end

	if not next(halogenCarbons) then
		return nil
	end

	local candidates = Chain.findLongestChains(carbons, adj)

	if #candidates == 0 then
		return nil
	end

	local best = nil
	local bestHalogenCount = -1
	local bestLocants = nil

	for _, candidate in ipairs(candidates) do
		local halogenCount = 0

		for _, carbon in ipairs(candidate) do
			if halogenCarbons[carbon] then
				halogenCount = halogenCount + 1
			end
		end

		-- Scribunto Lua has no "continue", so simply skip
		-- candidates with no halogen by wrapping the rest.
		if halogenCount > 0 then

			local function halogenLocants(reverse)
				local locants = {}

				for i, carbon in ipairs(candidate) do
					local locant = i

					if reverse then
						locant = #candidate - i + 1
					end

					for _, atomIndex in ipairs(neighbours(graph, carbon)) do
						if isHalogen(
							getAtom(graph, atomIndex).element
						) then
							table.insert(locants, locant)
						end
					end
				end

				table.sort(locants)
				return locants
			end

			local forward = halogenLocants(false)
			local backward = halogenLocants(true)
			local locants = forward

			if Chain.compareLocantLists(
				backward,
				forward
			) < 0 then
				locants = backward
			end

			if halogenCount > bestHalogenCount
				or (
					halogenCount == bestHalogenCount
					and (
						not bestLocants
						or Chain.compareLocantLists(
							locants,
							bestLocants
						) < 0
					)
				)
			then
				best = candidate
				bestHalogenCount = halogenCount
				bestLocants = locants
			end
		end
	end

	if not best then
		return nil
	end

	local chain = best
	local length = #chain
	local root = getRoot(length)

	if not root then
		return nil
	end

	------------------------------------------------------------------
	-- Choose numbering direction.
	------------------------------------------------------------------

	local function getHalogenLocants(reverse)
		local locants = {}

		for i, carbon in ipairs(chain) do
			local locant = i

			if reverse then
				locant = length - i + 1
			end

			for _, atomIndex in ipairs(neighbours(graph, carbon)) do
				if isHalogen(
					getAtom(graph, atomIndex).element
				) then
					table.insert(locants, locant)
				end
			end
		end

		table.sort(locants)
		return locants
	end

	local forwardHalogens = getHalogenLocants(false)
	local reverseHalogens = getHalogenLocants(true)

	local reversed = false

	if Chain.compareLocantLists(
		reverseHalogens,
		forwardHalogens
	) < 0 then
		reversed = true
	end

	------------------------------------------------------------------
	-- Collect substituents.
	------------------------------------------------------------------

	local substituents = {}

	for i, carbon in ipairs(chain) do
		local locant = i

		if reversed then
			locant = length - i + 1
		end

		for _, atomIndex in ipairs(neighbours(graph, carbon)) do
			local atom = getAtom(graph, atomIndex)

			if isHalogen(atom.element) then
				local name = halogens[atom.element]

				if not substituents[name] then
					substituents[name] = {}
				end

				table.insert(
					substituents[name],
					locant
				)
			end
		end

		for _, branch in ipairs(adj[carbon] or {}) do
			if not inPath(chain, branch) then
				local subtree = Chain.substituentSubtree(
					adj,
					branch,
					pathSet(chain)
				)

				if #subtree == 1 then
					if not substituents.methyl then
						substituents.methyl = {}
					end

					table.insert(
						substituents.methyl,
						locant
					)
				end
			end
		end
	end

	------------------------------------------------------------------
	-- Methane/ethane halogen names do not require locants.
	----------------------------------------------------------------------

	if length <= 2 then
		local parts = {}

		for name, locants in pairs(substituents) do
			if halogenElements[name]
				and #locants == 1
			then
				table.insert(parts, name)
			else
				local part = buildSubstituentPrefix(
					name,
					locants
				)

				if part then
					table.insert(parts, part)
				end
			end
		end

		table.sort(parts)

		return table.concat(parts, '-')
			.. root
			.. 'ane'
	end

	local parts = buildSubstituentPrefixList(
		substituents
	)

	if #parts == 0 then
		return root .. 'ane'
	end

	return table.concat(parts, '-')
		.. root
		.. 'ane'
end

----------------------------------------------------------------------
-- ETHER
----------------------------------------------------------------------

local function nameEther(graph)
	local oxygen = nil

	for i, atom in ipairs(graph.atoms) do
		if atom.element == 'O' then
			oxygen = i
			break
		end
	end

	if not oxygen then
		return nil
	end

	local oxygenNeighbours = heavyNeighbours(graph, oxygen)

	-- Ether: C-O-C
	if #oxygenNeighbours ~= 2 then
		return nil
	end

	if getAtom(
		graph,
		oxygenNeighbours[1]
	).element ~= 'C'
		or getAtom(
			graph,
			oxygenNeighbours[2]
		).element ~= 'C'
	then
		return nil
	end

	local function countSide(start)
		local visited = {
			[oxygen] = true
		}

		local queue = { start }
		local qi = 1
		local count = 0

		while qi <= #queue do
			local current = queue[qi]
			qi = qi + 1

			if not visited[current] then
				visited[current] = true

				if getAtom(
					graph,
					current
				).element ~= 'C'
				then
					return nil
				end

				count = count + 1

				for _, neighbour in ipairs(
					neighbours(graph, current)
				) do
					if not visited[neighbour]
						and neighbour ~= oxygen
					then
						local element =
							getAtom(
								graph,
								neighbour
							).element

						if element == 'C' then
							table.insert(
								queue,
								neighbour
							)
						elseif element ~= 'H' then
							return nil
						end
					end
				end
			end
		end

		return count
	end

	local left = countSide(
		oxygenNeighbours[1]
	)

	local right = countSide(
		oxygenNeighbours[2]
	)

	if not left or not right then
		return nil
	end

	local larger = math.max(left, right)
	local smaller = math.min(left, right)

	local largerRoot = getRoot(larger)
	local smallerRoot = getRoot(smaller)

	if not largerRoot or not smallerRoot then
		return nil
	end

	return smallerRoot
		.. 'oxy'
		.. largerRoot
		.. 'ane'
end

----------------------------------------------------------------------
-- ALKYL HYPOCHLORITE
----------------------------------------------------------------------

local function nameHypochlorite(graph)
	local oxygen = nil

	for i, atom in ipairs(graph.atoms) do
		if atom.element == 'O' then
			oxygen = i
			break
		end
	end

	if not oxygen then
		return nil
	end

	local oxygenNeighbours = heavyNeighbours(
		graph,
		oxygen
	)

	-- R-O-Cl
	if #oxygenNeighbours ~= 2 then
		return nil
	end

	local carbon = nil
	local chlorine = nil

	for _, neighbour in ipairs(oxygenNeighbours) do
		local element =
			getAtom(
				graph,
				neighbour
			).element

		if element == 'C' then
			if carbon then
				return nil
			end

			carbon = neighbour

		elseif element == 'Cl' then
			if chlorine then
				return nil
			end

			chlorine = neighbour

		else
			return nil
		end
	end

	if not carbon or not chlorine then
		return nil
	end

	local visited = {
		[oxygen] = true
	}

	local queue = { carbon }
	local qi = 1
	local count = 0

	while qi <= #queue do
		local current = queue[qi]
		qi = qi + 1

		if not visited[current] then
			visited[current] = true

			if getAtom(
				graph,
				current
			).element ~= 'C'
			then
				return nil
			end

			count = count + 1

			for _, neighbour in ipairs(
				neighbours(graph, current)
			) do
				if not visited[neighbour]
					and neighbour ~= oxygen
				then
					local element =
						getAtom(
							graph,
							neighbour
						).element

					if element == 'C' then
						table.insert(
							queue,
							neighbour
						)
					elseif element ~= 'H' then
						return nil
					end
				end
			end
		end
	end

	local root = getRoot(count)

	if not root then
		return nil
	end

	return root .. 'yl hypochlorite'
end

----------------------------------------------------------------------
-- MAIN
----------------------------------------------------------------------

function p.name(graph)

	-- Functional module only handles single bonds.
	for _, bond in ipairs(graph.bonds) do
		if bond.order ~= 1 then
			return nil,
				'double/triple bonds present'
		end
	end

	local carbons = getCarbons(graph)

	if #carbons == 0 then
		return nil, 'no carbon skeleton'
	end

	local adjacency = {}

	for _, carbon in ipairs(carbons) do
		adjacency[carbon] = {}
	end

	for _, bond in ipairs(graph.bonds) do
		if adjacency[bond.a]
			and adjacency[bond.b]
		then
			table.insert(
				adjacency[bond.a],
				bond.b
			)

			table.insert(
				adjacency[bond.b],
				bond.a
			)
		end
	end

	------------------------------------------------------------------
	-- Functional groups are checked BEFORE carbon-tree validation.
	--
	-- This is important for ethers such as CCOCC because the oxygen
	-- separates the carbon graph into two components.
	----------------------------------------------------------------------

	local alcohol = nameAlcohol(
		graph,
		carbons,
		adjacency
	)

	if alcohol then
		return alcohol
	end

	local hypochlorite = nameHypochlorite(graph)

	if hypochlorite then
		return hypochlorite
	end

	local ether = nameEther(graph)

	if ether then
		return ether
	end

	------------------------------------------------------------------
	-- Ordinary carbon skeleton.
	----------------------------------------------------------------------

	local isTree, err = Chain.isTree(
		carbons,
		adjacency
	)

	if not isTree then
		return nil,
			err .. ' — rings not supported'
	end

	local halo = nameHaloalkane(
		graph,
		carbons,
		adjacency
	)

	if halo then
		return halo
	end

	return nil,
		'functional group not supported yet'
end

return p
This page was redesigned at the edge.
