generate.cxx

Go to the documentation of this file.

/*
         Copyright 2020 Pierre SMARS (smars@yuntech.edu.tw)
         This program is free software: you can redistribute it and/or modify
         it under the terms of the GNU General Public License as published by
         the Free Software Foundation, either version 2 of the License, or
         (at your option) any later version.
 
         This program is distributed in the hope that it will be useful,
         but WITHOUT ANY WARRANTY; without even the implied warranty of
         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
         GNU General Public License for more details.
 
         You should have received a copy of the GNU General Public License
         along with this program.  If not, see <http://www.gnu.org/licenses/>.
         */
#include <iostream>
#include <sstream>
 
#include "SimpleOpt.h"
 
enum { OPT_HELP, OPT_TOPO};
 
CSimpleOpt::SOption g_rgOptions[] = {
        { OPT_TOPO, _T("-t"),     SO_NONE },
        { OPT_TOPO, _T("--topology"), SO_NONE },
        { OPT_HELP, _T("-?"),     SO_NONE    },
        { OPT_HELP, _T("-h"),     SO_NONE    },
        { OPT_HELP, _T("--help"), SO_NONE    },
        SO_END_OF_OPTIONS
};
 
//*********************************************************
//global variable
uint32_t n[] = {1,1,1};
//*********************************************************
int error(int val)
{
#include "generate.help"
        return val;
}
//*********************************************************
double v(const uint32_t step, const uint32_t n)
{
        if (n==1)
                return 0.;
        double s = step;
        return s/(n-1);
}
//*********************************************************
void tri(const uint32_t i, const uint32_t j)
{
        std::cout << i+j*n[0]   << " " << i+1+j*n[0] << " " << i+(j+1)*n[0] << "\n";
        std::cout << i+1+j*n[0] << " " << i+1+(j+1)*n[0] << " " << i+(j+1)*n[0] << "\n";
}
//*********************************************************
void tetra(const uint32_t a, const uint32_t b, const uint32_t c, const uint32_t d)
{
        std::cout << a << " " << b << " " << c << " " << d << "\n"; 
}
//*********************************************************
void quad(const uint32_t i, const uint32_t j, const uint32_t k)
{
        uint32_t a = n[0];
        uint32_t b = n[0]*n[1]; 
        tetra(i+j*a+k*b,i+1+j*a+k*b,i+(j+1)*a+k*b,i+j*a+(k+1)*b);
        tetra(i+1+j*a+k*b,i+1+(j+1)*a+k*b,i+(j+1)*a+k*b,i+1+(j+1)*a+(k+1)*b);
        tetra(i+1+j*a+k*b,i+(j+1)*a+k*b,i+j*a+(k+1)*b,i+1+j*a+(k+1)*b);
        tetra(i+(j+1)*a+k*b,i+(j+1)*a+(k+1)*b,i+j*a+(k+1)*b,i+1+j*a+(k+1)*b);
        tetra(i+1+j*a+k*b,i+1+(j+1)*a+(k+1)*b,i+(j+1)*a+k*b,i+1+j*a+(k+1)*b);
        tetra(i+(j+1)*a+k*b,i+1+(j+1)*a+(k+1)*b,i+(j+1)*a+(k+1)*b,i+1+j*a+(k+1)*b);
}
//*********************************************************
int main(int argc, char ** argv)
{
        bool topo = false;
        CSimpleOpt args(argc, argv, g_rgOptions);
        while (args.Next())
        {
                if (args.LastError() == SO_SUCCESS)
                {
                        if (args.OptionId() == OPT_HELP)
                                return error(0);
                        else if (args.OptionId() == OPT_TOPO)
                                topo = true;
                } else {
                        std::cerr << "Invalid argument: " << args.OptionText() << "\n";
                        return error(args.LastError());
                        // handle error, one of: SO_OPT_INVALID, SO_OPT_MULTIPLE,
                        // SO_ARG_INVALID, SO_ARG_INVALID_TYPE, SO_ARG_MISSING
                }
        }
        uint8_t dim = args.FileCount();
        if ((dim<1)||(dim>3)) return error(-2);
        std::ostringstream o;
        for (uint8_t i=0; i<dim;i++)
                o << args.File(i) << " ";
        std::istringstream in(o.str().c_str());
        for (uint8_t i=0; i<dim;i++)
        {
                uint32_t val;
                in >> val;
                if (val<2) return error(-3);
                n[i] = val;
        }
        uint32_t npts = 1;
        for (uint8_t i=0; i<dim;i++)
                npts *= n[i];
        std::cout << npts << "\n";
        for (uint32_t k=0; k<n[2];k++)
        {
                for (uint32_t j=0; j<n[1];j++)
                {
                        for (uint32_t i=0; i<n[0];i++)
                                std:: cout << v(i,n[0]) << " " << v(j,n[1]) << " " << v(k,n[2]) << "\n";
                }
        }
        if (topo)
        {
                switch (dim)
                {
                        case 1:
                                std::cout << n[0]-1 << "\n";
                                for (uint32_t u=0; u<n[0]-1;u++)
                                        std::cout << u << " " << u+1 << "\n";
                                break;
                        case 2:
                                std::cout << (n[0]-1)*(n[1]-1)*2 << "\n";
                                for (uint32_t v=0; v<n[1]-1;v++)
                                {
                                        for (uint32_t u=0; u<n[0]-1;u++)
                                                tri(u,v);
                                }
                                break;
                        case 3:
                                std::cout << (n[0]-1)*(n[1]-1)*(n[2]-1)*6 << "\n";
                                for (uint32_t w=0; w<n[2]-1;w++)
                                {
                                        for (uint32_t v=0; v<n[1]-1;v++)
                                        {
                                                for (uint32_t u=0; u<n[0]-1;u++)
                                                        quad(u,v,w);
                                        }
                                }
                }
        }
        return 0;
}