symop-map-generator.cpp File Reference

#include <cassert>
#include <array>
#include <iostream>
#include <iomanip>
#include <fstream>
#include <regex>
#include <map>
#include <filesystem>
#include <cstdlib>

Include dependency graph for symop-map-generator.cpp:

Go to the source code of this file.

Classes
class	SymopParser

Functions
std::regex	kNameRx (R"(^(\) +(\) +(\) +(\) +(\) +(\) +'([^']+)'( +'([^']+)')?(?: +!.+)?$)")
std::array< int, 15 >	move_symop (std::array< int, 15 > symop, const std::array< int, 15 > &cenop)
int	main (int argc, char *const argv[])

Function Documentation

kNameRx()

std::regex kNameRx

(

R"(^(\+(\+(\+(\+(\+(\+'([^']+)'( +'([^']+)')?(?: +!.+)?$)"

)

main()

int main	(	int	argc,
		char *const	argv[]
	)

Definition at line 225 of file symop-map-generator.cpp.

{
    using namespace std::literals;

    fs::path tmpFile;

    try
    {
        if (argc != 3)
        {
            std::cerr << "Usage symop-map-generator <input-file> <output-file>" << std::endl;
            exit(1);
        }

        fs::path input(argv[1]);
        fs::path output(argv[2]);
        
        tmpFile = output.parent_path() / (output.filename().string() + ".tmp");

        std::ofstream out(tmpFile);
        if (not out.is_open())
            throw std::runtime_error("Failed to open output file");

        // --------------------------------------------------------------------

        // store symop data here
        std::vector<std::tuple<int,int,std::array<int,15>>> data;

        // -----------------------------------------------------------------------
        
        struct SymInfoBlock
        {
            int nr;
            std::string xHM;
            std::string Hall;
            std::string old[2];
        };

        std::map<int,SymInfoBlock> symInfo;
        int symopnr, mysymnr = 10000;

        std::ifstream file(input);
        if (not file.is_open())
            throw std::runtime_error("Could not open syminfo.lib file");

        enum class State { skip, spacegroup } state = State::skip;

        std::string line;

        const std::regex rx(R"(^symbol +(Hall|xHM|old) +'(.+?)'(?: +'(.+?)')?$)"),
            rx2(R"(symbol ccp4 (\d+))");;

        SymInfoBlock cur = {};

        std::vector<std::array<int,15>> symops, cenops;

        while (getline(file, line))
        {
            switch (state)
            {
                case State::skip:
                    if (line == "begin_spacegroup")
                    {
                        state = State::spacegroup;
                        symopnr = 1;
                        ++mysymnr;
                        cur = { mysymnr };
                    }
                    break;
                
                case State::spacegroup:
                {
                    std::smatch m;
                    if (std::regex_match(line, m, rx))
                    {
                        if (m[1] == "old")
                        {
                            cur.old[0] = m[2];
                            if (m[3].matched)
                                cur.old[1] = m[3];
                        }
                        else if (m[1] == "xHM")
                            cur.xHM = m[2];
                        else if (m[1] == "Hall")
                            cur.Hall = m[2];
                    }
                    else if (regex_match(line, m, rx2))
                    {
                        int nr = stoi(m[1]);
                        if (nr != 0)
                            cur.nr = nr;
                    }
                    else if (line.compare(0, 6, "symop ") == 0)
                    {
                        SymopParser p;
                        symops.emplace_back(p.parse(line.substr(6)));
                    }
                    else if (line.compare(0, 6, "cenop ") == 0)
                    {
                        SymopParser p;
                        cenops.emplace_back(p.parse(line.substr(6)));
                    }
                    else if (line == "end_spacegroup")
                    {
                        for (auto& cenop: cenops)
                        {
                            for (auto symop: symops)
                            {
                                symop = move_symop(symop, cenop);

                                data.emplace_back(cur.nr, symopnr, symop);
                                ++symopnr;
                            }
                        }

                        symInfo.emplace(cur.nr, cur);
                        state = State::skip;

                        symops.clear();
                        cenops.clear();
                    }
                    break;
                }
            }
        }

        // --------------------------------------------------------------------

        sort(data.begin(), data.end());

        // --------------------------------------------------------------------

        out << R"(// This file was generated from $CLIBD/symop.lib
// and $CLIBD/syminfo.lib using symop-map-generator,
// part of the PDB-REDO suite of programs.

#include "cif++/symmetry.hpp"

namespace cif
{

const space_group kSpaceGroups[] =
{
)";

        std::vector<std::tuple<std::string,int,std::string,std::string>> spacegroups;

        for (auto& [nr, info]: symInfo)
        {
            spacegroups.emplace_back(info.old[0], nr, info.xHM, info.Hall);
            if (info.old[1].empty() == false)
                spacegroups.emplace_back(info.old[1], nr, info.xHM, info.Hall);
        }

        sort(spacegroups.begin(), spacegroups.end());

        for (auto [old, nr, xHM, Hall]: spacegroups)
        {
            old = '"' + old + '"' + std::string(20 - old.length(), ' ');
            xHM = '"' + xHM + '"' + std::string(30 - xHM.length(), ' ');

            for (std::string::size_type p = Hall.length(); p > 0; --p)
            {
                if (Hall[p - 1] == '"')
                    Hall.insert(p - 1, "\\", 1);
            }

            Hall = '"' + Hall + '"' + std::string(40 - Hall.length(), ' ');

            out << "\t{ " << old << ", " << xHM << ", " << Hall << ", " << nr << " }," << std::endl;
        }

out << R"(
};

const size_t kNrOfSpaceGroups = sizeof(kSpaceGroups) / sizeof(space_group);

const symop_datablock kSymopNrTable[] = {
)" << std::endl;

        int spacegroupNr = 0;
        for (auto& sd: data)
        {
            int sp, o;
            std::tie(sp, o, std::ignore) = sd;

            if (sp > spacegroupNr)
                out << "    // " << symInfo[sp].xHM << std::endl;
            spacegroupNr = sp;

            out << "    { " << std::setw(3) << sp
                    << ", " << std::setw(3) << o << ", { ";
            for (auto& i: std::get<2>(sd))
                out << std::setw(2) << i << ',';
            out << " } }," << std::endl;
        }

        out << R"(};

const size_t kSymopNrTableSize = sizeof(kSymopNrTable) / sizeof(symop_datablock);

} // namespace mmcif
)" << std::endl;

        out.close();
        fs::rename(tmpFile, output);
    }
    catch (const std::exception& ex)
    {
        std::cerr << std::endl
             << "Program terminated due to error:" << std::endl
             << ex.what() << std::endl;
    }
    
    return 0;
}

move_symop()

std::array<int,15> move_symop	(	std::array< int, 15 >	symop,
		const std::array< int, 15 > &	cenop
	)

Definition at line 181 of file symop-map-generator.cpp.

{
    for (int i = 9; i < 15; i += 2)
    {
        if (cenop[i] == 0)
            continue;
        
        assert(cenop[i + 1] != 0);

        if (symop[i] == 0)
        {
            assert(symop[i + 1] == 0);
            symop[i] = cenop[i];
            symop[i + 1] = cenop[i + 1];
            continue;
        }

        if (symop[i + 1] == cenop[i + 1])
            symop[i] += cenop[i];
        else
        {
            int d = symop[i + 1] * cenop[i + 1];
            int n = symop[i] * cenop[i + 1] + symop[i + 1] * cenop[i];

            symop[i] = n;
            symop[i + 1] = d;
        }

        for (int j = 5; j > 1; --j)
            if (symop[i] % j == 0 and symop[i + 1] % j == 0)
            {
                symop[i] /= j;
                symop[i + 1] /= j;
            }
        
        symop[i] = (symop[i] + symop[i + 1]) % symop[i + 1];

        if (symop[i] == 0)
            symop[i + 1] = 0;
    }

    return symop;
}