#define PROG_NAME "Unshellable"
#define PROG_DESC "???"
#define PROG_VERS "1.0"

/* Last edited on 2024-12-21 11:37:22 by stolfi */

#define Unshellable_C_COPYRIGHT \
  ""
  
#define PROG_INFO \
  "" \
  " "

#include <stdio.h>

#include <r4.h>
#include <argparser.h>

#include <Octf.h>
#include <Triangulation.h>
#include <Triangulation.h>

TYPE
typedef struct Options_t {
      uint gridOrder;
  }

TYPE
double @PLACES = ARRAY[0..3] OF Place_t;

Place_t MakeBigRawCube(uint order)
  /*  Build one tridimensional array of cubic cellulas with fixed geometry.*/
  VAR
    cd : REF ARRAY OF ARRAY OF ARRAY OF @PLACES;
  { cd = NEW(REF ARRAY OF ARRAY OF ARRAY OF @PLACES, 5, order, order);
    for (i = 0; i < 5; i++)
    {
      ??? cc = Squared.Make2DCubeArray(order);
    {
        for (j = 0; j < order; j++)
        {
          for (k = 0; k < order; k++)
          {
            for (l = 0; l < 2; l++)
            {
              cd[i,j,k,l] = cc.el[j,k,l];
            }
          }
        }
      }
    }

    /* gluing */
    for (i = 0; i < 4; i++)
    {
      for (k = 0; k < order; k++)
      {
        for (j = 0; j < order; j++)
        {
          GlueCube(cd[i,k,j,1],Clock(cd[i+1,k,j,0]));
        }
      }
    }

    /* Fix the coordinates */

    ??? top = MakeElemTable(cd[0;
    with (0,0,0],1),
    double r = NEW(REF Coords_t, top->node.nel);
    double c = r^;
    double name = "Bigcube-" & Fmt.Int(order);
    double zero = 0.0;
    double one = 1.0;
    double cmt = " "
  ){
       void SetCorner(e: Place_t; uint i)
         {
           ??? ii = FLOAT(i, double));
           with(
           double cv = (r4_t){ii,zero,zero,zero}
         ){
             c[OrgV(e)->num] = cv;
           }
         } SetCorner;

       void SetCorner1(e: Place_t; o: r4_t)
         {
           c[OrgV(e)->num] = (r4_t){o[0], o[1]+one, o[2], o[3]};
         } SetCorner1;

       void SetCorner2(e: Place_t; o: r4_t)
        {
          c[OrgV(e)->num] = (r4_t){o[0], o[1], o[2]+one, o[3]};
        } SetCorner2;

       void SetCorner3(e: Place_t; o: r4_t)
        {
          c[OrgV(e)->num] = (r4_t){o[0], o[1]-one, o[2], o[3]};
        } SetCorner3;

       Place_t *p;
       {
         for (i = 0; i < 5; i++)
         {
           SetCorner(Clock(NextE(cd[i,0,0,0])),i);
           for (j = 0; j < order; j++)
           {
             p = Clock(NextE(cd[i,j,0,0]));
             for (k = 0; k < order; k++)
             {
               SetCorner1(NextE(p),c[OrgV(p)->num]);
               SetCorner2(NextE(NextE(p)),c[OrgV(NextE(p))->num]);
               SetCorner3(NextE(NextE(NextE(p))),c[OrgV(NextE(NextE(p)))->num]);
               p = NextE(PrevF(PrevF(cd[i,j,k,0])));
             }
           }
          }

          /* finally */  
          SetCorner(PrevE(cd[4,0,0,1]),order);
          for (j = 0; j < order; j++)
          {
            p = PrevE(cd[4,j,0,1]);
            for (k = 0; k < order; k++)
            {
               SetCorner1(NextE(p),c[OrgV(p)->num]);
               SetCorner2(NextE(NextE(p)),c[OrgV(NextE(p))->num]);
               SetCorner3(NextE(NextE(NextE(p))),c[OrgV(NextE(NextE(p)))->num]);
               p = Clock(PrevE(NextF(cd[4,j,k,1])));
             }
           }
           WriteTopology(name,top);
           MakeElemTableTable(name, top, cmt);
           WriteState(name, top, c, cmt);
           WriteMaterials(name, top, cmt);
           
           return cd[0,0,0,0];
       }
    }
  } /* END MakeBigRawCube */


Options_t GetOptions ()
  { Options_t *o = (Options_t *)malloc(sizeof(Options_t));
    argparser_t *pp = argparser_new(stderr, argc, argv);
    argparser_set_help(pp, PROG_NAME " version " PROG_VERS ", usage:\n" PROG_HELP);
    argparser_set_info(pp, PROG_INFO);
    argparser_process_help_info_options(pp);
    
    argparser_get_keyword(pp, "-gridOrder");                               

        o->gridOrder = argparser_get_next_int(pp, 1,10);                         
        argparser_finish(pp);                                       

      
  -----------------------------------
#define _HELP \
  fprintf(stderr, "Usage: MakeRawCube -gridOrder <num>\n");
          
END¦                                              
      }
    }
    return o;
  } /* END GetOptions */


PROCEDURE Main()
  Place_t *a;
  { Options_t *o = GetOptions(argc, argv);
    char *topo_cmt = jsprintf("Created by %s on %s", PROG_NAME, Today());
    /* Random_t coins = MakeRandomSource(4615); */
    {
      a = MakeBigRawCube(o->gridOrder);
    }
  } /* END Main */

{
  Main();
} Unshellable.