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

#define MakePentaOcta_C_COPYRIGHT \
  ""
  
#define PROG_INFO \
  "" \
  " "

/* This program implements the automatic gluing of cells (tetrahedra,
   triangulated octahedra) for the 4D non-regular polytope: "Truncated
   Simplex", also know as: "PentaOcta".

   The Truncated Simplex has nv==10, ne==30, nf==30, np==10, self-dual. This
   3D map is a polytope, but not a regular polytope, since it has 5
   tetrahedral volumes and 5 octahedral volumes.
*/
   

#include <argparser.h>
#define _GNU_SOURCE
#include <stdio.h>
#include <Mis.h>
#include <Triangulation.h>
#include <Octf.h>

TYPE 
double Row2I = ARRAY[0..1] OF uint;
double z4_t = ARRAY[0..3] OF uint;

typedef struct Options_t {
    bool_t detail;
  }
 
CONST
double INIT_STACK_SIZE = 700;
  cellnum      ==  45;

VAR
  cell4 = NEW(REF ARRAY OF z4_t, INIT_STACK_SIZE);
  tetra : REF ARRAY OF ARRAY [0..3] OF Place_t;
  Options_t o;  

Options_t *GetOptions(int argc, char **argv);

int main(int argc, char **argv)
  

  Place_t GlueTetras(Ti,Tj,Ci,Cj: uint)
    /* Gluing the tetrahedra Ti with Tj through the free walls Ci and
       Cj respectively. 
    */

    void PrintInfo(case: uint;oi,oj,di,dj: uint)
      /* Prints information about the three possible cases in the
         gluing procedure.
      */
      {
        fprintf(stderr, "case " & Fmt.Int(case) & ": ");  
        fprintf(stderr, Fmt.Int(oi) & " " & Fmt.Int(di)&"\n");
        fprintf(stderr, "                    ");
        fprintf(stderr, Fmt.Int(oj) & " " & Fmt.Int(dj)&"\n\n");
      } PrintInfo;

    void UngluedInfo(ci,cj,ti,tj: uint)
      /* Prints information about unglued case in the gluing procedure.
         This procedure cause the halt of the program.
      */
      {
        fprintf(stderr, "Not glue this case " & Fmt.Int(ci) & " " \
          Fmt.Int(cj) & "\n");
        fprintf(stderr, "   Tetrahedra " & Fmt.Int(ti) & " " \
          Fmt.Int(tj) & "\n");
        Process.Exit¦(1);
      } UngluedInfo;

    {
      if (o->detail)
      {
        fprintf(stderr,"Ci=="&Fmt.Int(Ci)&" Cj=="&Fmt.Int(Cj)&",  ");
      }
      IF
       /* 1 */ 
     double Ci = 0) && (Cj == 0))
     {
       int Oi = cell4[Ti].ix[0];
       int Di = cell4[Ti].ix[1]
       {
         int Oj = cell4[Tj].ix[0];
         int Dj = cell4[Tj].ix[1]
          { 
           if ((Oi == Dj) && (Di == Oj))
           {
             if (o->detail){ PrintInfo(1,Oi,Oj,Di,Dj); }
             Glue(Clock(tetra[Tj].p[Cj]), tetra[Ti].p[Ci], 1);
             return    Clock(tetra[Tj].p[Cj]);
           }
         }
         int Oj = cell4[Tj].ix[1];
         int Dj = cell4[Tj].ix[3];
          { 
           if ((Oi == Dj) && (Di == Oj))
           {
             if (o->detail){ PrintInfo(2,Oi,Oj,Di,Dj); }
             Glue(Clock(NextE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Clock(NextE(tetra[Tj].p[Cj]));
           }
         }
         int Oj = cell4[Tj].ix[3];
         int Dj = cell4[Tj].ix[0]
         { 
           if ((Oi == Dj) && (Di == Oj))
           {
             if (o->detail){ PrintInfo(3,Oi,Oj,Di,Dj); }
             Glue(Clock(PrevE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Clock(PrevE(tetra[Tj].p[Cj]));
           }
         }
         UngluedInfo(Ci,Cj,Ti,Tj);
       }
      ELSIF
       /* 2 */
     double Ci = 0) && (Cj == 1))
     {
       int Oi = cell4[Ti].ix[0];
       int Di = cell4[Ti].ix[1]
       {
         int Oj = cell4[Tj].ix[0];
         int Dj = cell4[Tj].ix[1]
          { 
           if ((Oi == Oj) && (Di == Dj))
           {
             if (o->detail){ PrintInfo(1,Oi,Oj,Di,Dj); }
             Glue(Spin(tetra[Tj].p[Cj]), tetra[Ti].p[Ci], 1);
             return    Spin(tetra[Tj].p[Cj]);
           }
         }
         int Oj = cell4[Tj].ix[1];
         int Dj = cell4[Tj].ix[2]
          { 
           if ((Oi == Oj) && (Di == Dj))
           {
             if (o->detail){ PrintInfo(2,Oi,Oj,Di,Dj); }
             Glue(Spin(NextE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Spin(NextE(tetra[Tj].p[Cj]));
           }
         }
         int Oj = cell4[Tj].ix[2];
         int Dj = cell4[Tj].ix[0]
          { 
           if ((Oi == Oj) && (Di == Dj))
           {
            if (o->detail){  PrintInfo(3,Oi,Oj,Di,Dj); }
             Glue(Spin(PrevE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Spin(PrevE(tetra[Tj].p[Cj]));
           }
         }
         UngluedInfo(Ci,Cj,Ti,Tj);
       }
      ELSIF
       /* 3 */
     double Ci = 0) && (Cj == 2))
     {
       int Oi = cell4[Ti].ix[0];
       int Di = cell4[Ti].ix[1]
       {
         int Oj = cell4[Tj].ix[2];
         int Dj = cell4[Tj].ix[3]
          {
           if ((Oi == Oj) && (Di == Dj))
           {
             if (o->detail){ PrintInfo(1,Oi,Oj,Di,Dj); }
             Glue(Spin(tetra[Tj].p[Cj]), tetra[Ti].p[Ci], 1);
             return Spin(tetra[Tj].p[Cj]);
           }
         }
         int Oj = cell4[Tj].ix[3];
         int Dj = cell4[Tj].ix[0]
         { 
           if ((Oi == Oj) && (Di == Dj))
           {
             if (o->detail){ PrintInfo(2,Oi,Oj,Di,Dj); }
             Glue(Spin(NextE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Spin(NextE(tetra[Tj].p[Cj]));
           }
         }
         int Oj = cell4[Tj].ix[0];
         int Dj = cell4[Tj].ix[2]
          { 
           if ((Oi == Oj) && (Di == Dj))
           {
            if (o->detail){  PrintInfo(3,Oi,Oj,Di,Dj); }
             Glue(Spin(PrevE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Spin(PrevE(tetra[Tj].p[Cj]));
           }
         }
         UngluedInfo(Ci,Cj,Ti,Tj);
       }
      ELSIF
       /* 4 */
     double Ci = 0) && (Cj == 3))
     {
       int Oi = cell4[Ti].ix[0];
       int Di = cell4[Ti].ix[1]
       {
         int Oj = cell4[Tj].ix[2];
         int Dj = cell4[Tj].ix[3]
          {
           if ((Oi == Dj) && (Di == Oj))
           {
             if (o->detail){ PrintInfo(1,Oi,Oj,Di,Dj); }
             Glue(Clock(tetra[Tj].p[Cj]), tetra[Ti].p[Ci], 1);
             return    Clock(tetra[Tj].p[Cj]);
           }
         } 
         int Oj = cell4[Tj].ix[3];
         int Dj = cell4[Tj].ix[1];
          {
           if ((Oi == Dj) && (Di == Oj))
           {
             if (o->detail){ PrintInfo(2,Oi,Oj,Di,Dj); } 
             Glue(Clock(NextE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Clock(NextE(tetra[Tj].p[Cj]));
           }
         }
         int Oj = cell4[Tj].ix[1];
         int Dj = cell4[Tj].ix[2]
          {
           if ((Oi == Dj) && (Di == Oj))
           {
             if (o->detail){  PrintInfo(3,Oi,Oj,Di,Dj); } 
             Glue(Clock(PrevE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Clock(PrevE(tetra[Tj].p[Cj]));
           }
         }
         UngluedInfo(Ci,Cj,Ti,Tj);
       } 
      ELSIF
       /* 5 */
     double Ci = 1) && (Cj == 0))
     {
       int Oi = cell4[Ti].ix[0];
       int Di = cell4[Ti].ix[1]
       {
         int Oj = cell4[Tj].ix[0];
         int Dj = cell4[Tj].ix[1]
          {
           if ((Oi == Oj) && (Di == Dj))
           {
             if (o->detail){ PrintInfo(1,Oi,Oj,Di,Dj); }
             Glue(Spin(tetra[Tj].p[Cj]), tetra[Ti].p[Ci], 1);
             return    Spin(tetra[Tj].p[Cj]);
           }
         }
         int Oj = cell4[Tj].ix[1];
         int Dj = cell4[Tj].ix[3];
          {
           if ((Oi == Oj) && (Di == Dj))
           {
             if (o->detail){ PrintInfo(2,Oi,Oj,Di,Dj); }
             Glue(Spin(NextE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Spin(NextE(tetra[Tj].p[Cj]));
           }
         }
         int Oj = cell4[Tj].ix[3];
         int Dj = cell4[Tj].ix[0]
         {
           if ((Oi == Oj) && (Di == Dj))
           {
            if (o->detail){  PrintInfo(3,Oi,Oj,Di,Dj); }
             Glue(Spin(PrevE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Spin(PrevE(tetra[Tj].p[Cj]));
           }
         }
         UngluedInfo(Ci,Cj,Ti,Tj);
       }
      ELSIF
       /* 6 */
     double Ci = 1) && (Cj == 1))
     {
       int Oi = cell4[Ti].ix[0];
       int Di = cell4[Ti].ix[1]
       {
         int Oj = cell4[Tj].ix[0];
         int Dj = cell4[Tj].ix[1]
          {  
           if ((Oi == Dj) && (Di == Oj))
           {
             if (o->detail){ PrintInfo(1,Oi,Oj,Di,Dj); }
             Glue(Clock(tetra[Tj].p[Cj]), tetra[Ti].p[Ci], 1);
             return    Clock(tetra[Tj].p[Cj]);
           }
         }
         int Oj = cell4[Tj].ix[1];
         int Dj = cell4[Tj].ix[2]
          {  
           if ((Oi == Dj) && (Di == Oj))
           {
             if (o->detail){ PrintInfo(2,Oi,Oj,Di,Dj); }
             Glue(Clock(NextE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Clock(NextE(tetra[Tj].p[Cj]));
           }
         }
         int Oj = cell4[Tj].ix[2];
         int Dj = cell4[Tj].ix[0]
          {  
           if ((Oi == Dj) && (Di == Oj))
           {
            if (o->detail){  PrintInfo(3,Oi,Oj,Di,Dj); }
             Glue(Clock(PrevE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Clock(PrevE(tetra[Tj].p[Cj]));
           }
         }
         UngluedInfo(Ci,Cj,Ti,Tj);
       }
      ELSIF
       /* 7 */
     double Ci = 1) && (Cj == 2))
     {
       int Oi = cell4[Ti].ix[0];
       int Di = cell4[Ti].ix[1]
       {
         int Oj = cell4[Tj].ix[2];
         int Dj = cell4[Tj].ix[3]
          {  
           if ((Oi == Dj) && (Di == Oj))
           {
             if (o->detail){ PrintInfo(1,Oi,Oj,Di,Dj); }
             Glue(Clock(tetra[Tj].p[Cj]), tetra[Ti].p[Ci], 1);
             return    Clock(tetra[Tj].p[Cj]);
           }
         }
         int Oj = cell4[Tj].ix[3];
         int Dj = cell4[Tj].ix[0]
         {          
           if ((Oi == Dj) && (Di == Oj))
           {
             if (o->detail){ PrintInfo(2,Oi,Oj,Di,Dj); }
             Glue(Clock(NextE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Clock(NextE(tetra[Tj].p[Cj]));
           }
         }
         int Oj = cell4[Tj].ix[0];
         int Dj = cell4[Tj].ix[2]
          {          
           if ((Oi == Dj) && (Di == Oj))
           {
            if (o->detail){  PrintInfo(3,Oi,Oj,Di,Dj); }
             Glue(Clock(PrevE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Clock(PrevE(tetra[Tj].p[Cj]));
           }
         }
         UngluedInfo(Ci,Cj,Ti,Tj);
       }
      ELSIF
       /* 8 */
     double Ci = 1) && (Cj == 3))
     {
       int Oi = cell4[Ti].ix[0];
       int Di = cell4[Ti].ix[1]
       {
         int Oj = cell4[Tj].ix[2];
         int Dj = cell4[Tj].ix[3]
          {
           if ((Oi == Oj) && (Di == Dj))
           {
             if (o->detail){ PrintInfo(1,Oi,Oj,Di,Dj); }
             Glue(Spin(tetra[Tj].p[Cj]), tetra[Ti].p[Ci], 1);
             return    Spin(tetra[Tj].p[Cj]);
           }
         }
         int Oj = cell4[Tj].ix[3];
         int Dj = cell4[Tj].ix[1];
          {
           if ((Oi == Oj) && (Di == Dj))
           {
             if (o->detail){ PrintInfo(2,Oi,Oj,Di,Dj); }
             Glue(Spin(NextE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Spin(NextE(tetra[Tj].p[Cj]));
           }
         }
         int Oj = cell4[Tj].ix[1];
         int Dj = cell4[Tj].ix[2]
          {
           if ((Oi == Oj) && (Di == Dj))
           {
            if (o->detail){  PrintInfo(3,Oi,Oj,Di,Dj); }
             Glue(Spin(PrevE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Spin(PrevE(tetra[Tj].p[Cj]));
           }
         }
         UngluedInfo(Ci,Cj,Ti,Tj);
       } 
      ELSIF
       /* 9 */
     double Ci = 2) && (Cj == 0))
     {
       int Oi = cell4[Ti].ix[2];
       int Di = cell4[Ti].ix[3];
       {
         int Oj = cell4[Tj].ix[0];
         int Dj = cell4[Tj].ix[1]
          {
           if ((Oi == Oj) && (Di == Dj))
           {
             if (o->detail){ PrintInfo(1,Oi,Oj,Di,Dj); }
             Glue(Spin(tetra[Tj].p[Cj]), tetra[Ti].p[Ci], 1);
             return    Spin(tetra[Tj].p[Cj]);
           }
         }
         int Oj = cell4[Tj].ix[1];
         int Dj = cell4[Tj].ix[3];
          {
           if ((Oi == Oj) && (Di == Dj))
           {
             if (o->detail){ PrintInfo(2,Oi,Oj,Di,Dj); }
             Glue(Spin(NextE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Spin(NextE(tetra[Tj].p[Cj]));
           }
         }
         int Oj = cell4[Tj].ix[3];
         int Dj = cell4[Tj].ix[0]
         {
           if ((Oi == Oj) && (Di == Dj))
           {
            if (o->detail){  PrintInfo(3,Oi,Oj,Di,Dj); }
             Glue(Spin(PrevE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Spin(PrevE(tetra[Tj].p[Cj]));
           }
         }
         UngluedInfo(Ci,Cj,Ti,Tj);
       }
      ELSIF
       /* 10 */
     double Ci = 2) && (Cj == 1))
     {
       int Oi = cell4[Ti].ix[2];
       int Di = cell4[Ti].ix[3];
       {
         int Oj = cell4[Tj].ix[0];
         int Dj = cell4[Tj].ix[1]
          {
           if ((Oi == Dj) && (Di == Oj))
           {
             if (o->detail){ PrintInfo(1,Oi,Oj,Di,Dj); }
             Glue(Clock(tetra[Tj].p[Cj]), tetra[Ti].p[Ci], 1);
             return    Clock(tetra[Tj].p[Cj]);
           }
         }
         int Oj = cell4[Tj].ix[1];
         int Dj = cell4[Tj].ix[2]
          {
           if ((Oi == Dj) && (Di == Oj))
           {
             if (o->detail){ PrintInfo(2,Oi,Oj,Di,Dj); }
             Glue(Clock(NextE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Clock(NextE(tetra[Tj].p[Cj]));
           }
         }
         int Oj = cell4[Tj].ix[2];
         int Dj = cell4[Tj].ix[0]
          {
           if ((Oi == Dj) && (Di == Oj))
           {
            if (o->detail){  PrintInfo(3,Oi,Oj,Di,Dj); }
             Glue(Clock(PrevE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Clock(PrevE(tetra[Tj].p[Cj]));
           }
         }
         UngluedInfo(Ci,Cj,Ti,Tj);
       }
      ELSIF
       /* 11 */
     double Ci = 2) && (Cj == 2))
     {
       int Oi = cell4[Ti].ix[2];
       int Di = cell4[Ti].ix[3];
       {
         int Oj = cell4[Tj].ix[2];
         int Dj = cell4[Tj].ix[3];
         {
           if ((Oi == Dj) && (Di == Oj))
           {
             if (o->detail){ PrintInfo(1,Oi,Oj,Di,Dj); }
             Glue(Clock(tetra[Tj].p[Cj]), tetra[Ti].p[Ci], 1);
             return    Clock(tetra[Tj].p[Cj]);
           }
         }
         int Oj = cell4[Tj].ix[3];
         int Dj = cell4[Tj].ix[0];
         {
           if ((Oi == Dj) && (Di == Oj))
           {
             if (o->detail){ PrintInfo(2,Oi,Oj,Di,Dj); } 
             Glue(Clock(NextE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Clock(NextE(tetra[Tj].p[Cj]));
           }
         }
         int Oj = cell4[Tj].ix[0];
         int Dj = cell4[Tj].ix[2];
         {
           if ((Oi == Dj) && (Di == Oj))
           {
            if (o->detail){  PrintInfo(3,Oi,Oj,Di,Dj); }
             Glue(Clock(PrevE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Clock(PrevE(tetra[Tj].p[Cj]));
           }
         }
         UngluedInfo(Ci,Cj,Ti,Tj);
       }
      ELSIF
       /* 12 */
     double Ci = 2) && (Cj == 3))
     {
       int Oi = cell4[Ti].ix[2];
       int Di = cell4[Ti].ix[3];
       {
         int Oj = cell4[Tj].ix[2];
         int Dj = cell4[Tj].ix[3]
          {
           if ((Oi == Oj) && (Di == Dj))
           {
             if (o->detail){ PrintInfo(1,Oi,Oj,Di,Dj); }
             Glue(Spin(tetra[Tj].p[Cj]), tetra[Ti].p[Ci], 1);
             return Spin(tetra[Tj].p[Cj]);
           }
         }
         int Oj = cell4[Tj].ix[3];
         int Dj = cell4[Tj].ix[1];
          {         
           if ((Oi == Oj) && (Di == Dj))
           {
             if (o->detail){ PrintInfo(2,Oi,Oj,Di,Dj); }
             Glue(Spin(NextE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Spin(NextE(tetra[Tj].p[Cj]));
           }
         }
         int Oj = cell4[Tj].ix[1];
         int Dj = cell4[Tj].ix[2]
          {         
           if ((Oi == Oj) && (Di == Dj))
           {
            if (o->detail){  PrintInfo(3,Oi,Oj,Di,Dj); }
             Glue(Spin(PrevE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Spin(PrevE(tetra[Tj].p[Cj]));
           }
         }
         UngluedInfo(Ci,Cj,Ti,Tj);
       }
      ELSIF
       /* 13 */
     double Ci = 3) && (Cj == 0))
     {
       int Oi = cell4[Ti].ix[2];
       int Di = cell4[Ti].ix[3];
       {
         int Oj = cell4[Tj].ix[0];
         int Dj = cell4[Tj].ix[1]
          {
           if ((Oi == Dj) && (Di == Oj))
           {
             if (o->detail){ PrintInfo(1,Oi,Oj,Di,Dj); }
             Glue(Clock(tetra[Tj].p[Cj]), tetra[Ti].p[Ci], 1);
             return    Clock(tetra[Tj].p[Cj]);
           }
         }
         int Oj = cell4[Tj].ix[1];
         int Dj = cell4[Tj].ix[3];
          {
           if ((Oi == Dj) && (Di == Oj))
           {
             if (o->detail){ PrintInfo(2,Oi,Oj,Di,Dj); }
             Glue(Clock(NextE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Clock(NextE(tetra[Tj].p[Cj]));
           }
         }
         int Oj = cell4[Tj].ix[3];
         int Dj = cell4[Tj].ix[0]
         {
           if ((Oi == Dj) && (Di == Oj))
           {
            if (o->detail){  PrintInfo(3,Oi,Oj,Di,Dj); }
             Glue(Clock(PrevE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Clock(PrevE(tetra[Tj].p[Cj]));
           }
         }
         UngluedInfo(Ci,Cj,Ti,Tj);
       }
      ELSIF
       /* 14 */ 
     double Ci = 3) && (Cj == 1))
     {
       int Oi = cell4[Ti].ix[2];
       int Di = cell4[Ti].ix[3];
       {
         int Oj = cell4[Tj].ix[0];
         int Dj = cell4[Tj].ix[1]
          {
           if ((Oi == Oj) && (Di == Dj))
           {
             if (o->detail){ PrintInfo(1,Oi,Oj,Di,Dj); }
             Glue(Spin(tetra[Tj].p[Cj]), tetra[Ti].p[Ci], 1);
             return    Spin(tetra[Tj].p[Cj]);
           }
         }
         int Oj = cell4[Tj].ix[1];
         int Dj = cell4[Tj].ix[2]
          {
           if ((Oi == Oj) && (Di == Dj))
           {
             if (o->detail){ PrintInfo(2,Oi,Oj,Di,Dj); }
             Glue(Spin(NextE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Spin(NextE(tetra[Tj].p[Cj]));
           }
         }
         int Oj = cell4[Tj].ix[2];
         int Dj = cell4[Tj].ix[0]
          {
           if ((Oi == Oj) && (Di == Dj))
           {
            if (o->detail){  PrintInfo(3,Oi,Oj,Di,Dj); }
             Glue(Spin(PrevE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Spin(PrevE(tetra[Tj].p[Cj]));
           }
         }
         UngluedInfo(Ci,Cj,Ti,Tj);
       }
      ELSIF
       /* 15 */
     double Ci = 3) && (Cj == 2))
     {
       int Oi = cell4[Ti].ix[2];
       int Di = cell4[Ti].ix[3];
       {
         int Oj = cell4[Tj].ix[2];
         int Dj = cell4[Tj].ix[3]
          {
           if ((Oi == Oj) && (Di == Dj))
           {
             if (o->detail){ PrintInfo(1,Oi,Oj,Di,Dj); }
             Glue(Spin(tetra[Tj].p[Cj]), tetra[Ti].p[Ci], 1);
             return Spin(tetra[Tj].p[Cj]);
           }
         }
         int Oj = cell4[Tj].ix[3];
         int Dj = cell4[Tj].ix[0]
         {
           if ((Oi == Oj) && (Di == Dj))
           {
             if (o->detail){ PrintInfo(2,Oi,Oj,Di,Dj); }
             Glue(Spin(NextE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Spin(NextE(tetra[Tj].p[Cj]));
           }
         }
         int Oj = cell4[Tj].ix[0];
         int Dj = cell4[Tj].ix[2]
          {
           if ((Oi == Oj) && (Di == Dj))
           {
            if (o->detail){  PrintInfo(3,Oi,Oj,Di,Dj); }
             Glue(Spin(PrevE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Spin(PrevE(tetra[Tj].p[Cj]));
           }
         }
         UngluedInfo(Ci,Cj,Ti,Tj);
       }
      ELSIF
       /* 16 */
     double Ci = 3) && (Cj == 3))
     {
       int Oi = cell4[Ti].ix[2];
       int Di = cell4[Ti].ix[3];
       {
         int Oj = cell4[Tj].ix[2];
         int Dj = cell4[Tj].ix[3]
          {
           if ((Oi == Dj) && (Di == Oj))
           {
             if (o->detail){ PrintInfo(1,Oi,Oj,Di,Dj); }
             Glue(Clock(tetra[Tj].p[Cj]), tetra[Ti].p[Ci], 1);
             return    Clock(tetra[Tj].p[Cj]);
           }
         }
         int Oj = cell4[Tj].ix[3];
         int Dj = cell4[Tj].ix[1];
          {
           if ((Oi == Dj) && (Di == Oj))
           {
             if (o->detail){ PrintInfo(2,Oi,Oj,Di,Dj); }
             Glue(Clock(NextE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Clock(NextE(tetra[Tj].p[Cj]));
           }
         }
         int Oj = cell4[Tj].ix[1];
         int Dj = cell4[Tj].ix[2]
          {
           if ((Oi == Dj) && (Di == Oj))
           {
            if (o->detail){  PrintInfo(3,Oi,Oj,Di,Dj); } 
             Glue(Clock(PrevE(tetra[Tj].p[Cj])), tetra[Ti].p[Ci], 1);
             return    Clock(PrevE(tetra[Tj].p[Cj]));
           }
         }
         UngluedInfo(Ci,Cj,Ti,Tj);
       }
      }
    return tetra[Ti].p[0];
  } /* END GlueTetras */

  void SetCornersTetra(uint Ti, z4_t row)
    /* Set the labels "row" in the tetrahedron Ti. */
    {
      Node_t a = OrgV(tetra[Ti].p[0]);
        with (
      double b = OrgV(Clock(tetra[Ti].p[0]));
      double c = OrgV(PrevE(tetra[Ti].p[1]));
      double d = OrgV(PrevE(tetra[Ti].p[0]))
    ){
        a->num = row[0];
        b->num = row[1];
        c->num = row[2];
        d->num = row[3];
      }
    } SetCornersTetra;

  void SetGhostElementsS(Tuint i)
    /* Set one node, three @{edge->?}s and walls, such that the gluing of eigth
       tetrahedra, resemble an octahedron. This procedure set the upper tetrahedra.
    */
    {
      Node_t v0 = OrgV(tetra[Ti].p[0]);
        with (
      double e0 = PWedge(tetra[Ti].p[0]).edge;
      double e1 = PWedge(PrevE(tetra[Ti].p[0])).edge;
      double e2 = PWedge(PrevE(tetra[Ti].p[1])).edge;
      double f0 = PWedge(tetra[Ti].p[0]).wall;
      double f1 = PWedge(tetra[Ti].p[1]).wall;
      double f2 = PWedge(tetra[Ti].p[2]).wall
    ){
        v0->exists = FALSE;
        e0->exists = FALSE;
        e1->exists = FALSE;
        e2->exists = FALSE;
        f0->exists = FALSE;
        f1->exists = FALSE;
        f2->exists = FALSE;
      }
    } SetGhostElementsS;

  void SetGhostElementsI(Tuint i)
    /* Set one node, three @{edge->?}s and walls, such that the gluing of eigth
       tetrahedra, resemble an octahedron. This procedure set the lower tetrahedra.
    */
    {
      ??? v1 = OrgV(Clock(tetra[Ti;
        with (0])),
      double e0 = PWedge(tetra[Ti].p[0]).edge;
      double e1 = PWedge(NextE(tetra[Ti].p[0])).edge;
      double e2 = PWedge(NextE(tetra[Ti].p[1])).edge;
      double f0 = PWedge(tetra[Ti].p[0]).wall;
      double f1 = PWedge(tetra[Ti].p[1]).wall;
      double f2 = PWedge(tetra[Ti].p[3]).wall
    ){
        v1->exists = FALSE;
        e0->exists = FALSE;
        e1->exists = FALSE;
        e2->exists = FALSE;
        f0->exists = FALSE;
        f1->exists = FALSE;
        f2->exists = FALSE;
      }
    } SetGhostElementsI;

  bool_t MustBeGlued(Ti,Tj: Place_t)
    /* Return TRUE if the walls "PWall(Ti)" and
       "PWall(Tj)" have coherent orientations and
       must be glued.
    */
    {
      Node_t a = OrgV(Ti)->num;
      Node_t ae = OrgV(NextE(Ti))->num;
      ??? ae_1 = OrgV(PrevE(Ti))->num;
      Node_t b = OrgV(Tj)->num;
      Node_t be = OrgV(NextE(Tj))->num;
      ??? be_1 = OrgV(PrevE(Tj))->num;
      {
        if (((a == b) && (ae == be) && (ae_1 == be_1) OR
           (a == b) && (ae == be_1) && (ae_1 == be))){ return TRUE; }
        return FALSE
      }  
    } MustBeGlued;

  bool_t BadAttribution(Ti,Tj: Place_t)
    /* Return TRUE if the walls "PWall(Ti)" and
       "PWall(Tj)" have incoherent orientations.
    */
    {
      Node_t i0 = OrgV(Ti)->num;
      ??? i1 = OrgV(NextE(Ti))->num;
      ??? i2 = OrgV(PrevE(Ti))->num;
      Node_t j0 = OrgV(Tj)->num;
      ??? j1 = OrgV(NextE(Tj))->num;
      ??? j2 = OrgV(PrevE(Tj))->num;
      {
        if ((SpinBit(Ti)!=SpinBit(Tj)))
        {
          if (((i0 == j0) && (i1 == j2) && (i2 == j1) OR
             (i0 == j2) && (i1 == j1) && (i2 == j0) OR
             (i0 == j1) && (i1 == j0) && (i2 == j2)
           )){ return TRUE
          }
        };
        if ((SpinBit(Ti) == SpinBit(Tj)))
        {
          if (((i0 == j0) && (i1 == j1) && (i2 == j2) OR
             (i0 == j2) && (i0 == j0) && (i2 == j1) OR
             (i0 == j1) && (i1 == j2) && (i2 == j0)
           )){ return TRUE
          }
        };
        return FALSE
      }  
    } BadAttribution;

  void PrintCorners(Tuint i)
    /* Print the corners of the triangular wall "Ti". */
    {
      Node_t a = OrgV(walls[Ti])->num;
      Node_t ae = OrgV(NextE(walls[Ti]))->num;
      ??? ae_1 = OrgV(PrevE(walls[Ti]))->num;
      {
        fprintf(stderr, Fmt.Pad(Fmt.Int(a),3) & " " \
          Fmt.Pad(Fmt.Int(ae),3) \
          " " & Fmt.Pad(Fmt.Int(ae_1),3) & " ");
      }  
    } PrintCorners;
           
    REF ARRAY OF EightPlaces_t poly ;
      id    : uint = 0;
      count : uint = 1;
      walls : REF Place_vec_t;
      glues : REF ARRAY OF z4_t;
    {
      o = GetOptions();
      poly  = NEW(REF ARRAY OF EightPlaces_t,cellnum);
      tetra = NEW(REF ARRAY OF ARRAY [0..3] OF Place_t,cellnum);
        
      Place_vec_t walls = Place_vec_new( 4*cellnum);
      glues = NEW(REF ARRAY OF z4_t, 2*cellnum);
      /* Create topological tetrahedra */
      for (i = 0; i < cellnum; i++)
      {
        poly[i] = MakeTetraTopo(1,1);
      }

      /* Create the tetrahedra */
      for (i = 0; i < cellnum; i++)
      {
        for (j = 0; j < 4; j++)
        {
          tetra[i].p[j] = poly[i,j];
          assert(PposP(tetra[i].p[j]) == NULL);
        }
      }
        
      /* cells with corners perfectly assigments */

      /* the five first tetrahedra */ 
      cell4[0]  = (z4_t){{1,9,4,8}};
      cell4[1]  = (z4_t){{5,6,0,4}};
      cell4[2]  = (z4_t){{8,3,7,6}};
      cell4[3]  = (z4_t){{1,2,3,0}};
      cell4[4]  = (z4_t){{9,7,2,5}};

      /* octahedron 1 */ 
      cell4[5]  = (z4_t){{101,9,7,8}}; SetGhostElementsS(5);
      cell4[6]  = (z4_t){{101,9,8,4}}; SetGhostElementsS(6);
      cell4[7]  = (z4_t){{101,9,4,5}}; SetGhostElementsS(7);
      cell4[8]  = (z4_t){{101,9,5,7}}; SetGhostElementsS(8);
      cell4[9]  = (z4_t){{6,101,7,8}}; SetGhostElementsI(9);
      cell4[10] = (z4_t){{6,101,8,4}}; SetGhostElementsI(10);
      cell4[11] = (z4_t){{6,101,4,5}}; SetGhostElementsI(11);
      cell4[12] = (z4_t){{6,101,5,7}}; SetGhostElementsI(12);

      /* octahedron 2 */ 
      cell4[13] = (z4_t){{102,2,5,0}}; SetGhostElementsS(13);
      cell4[14] = (z4_t){{102,2,0,3}}; SetGhostElementsS(14);
      cell4[15] = (z4_t){{102,2,3,7}}; SetGhostElementsS(15);
      cell4[16] = (z4_t){{102,2,7,5}}; SetGhostElementsS(16);
      cell4[17] = (z4_t){{6,102,5,0}}; SetGhostElementsI(17);
      cell4[18] = (z4_t){{6,102,0,3}}; SetGhostElementsI(18);
      cell4[19] = (z4_t){{6,102,3,7}}; SetGhostElementsI(19);
      cell4[20] = (z4_t){{6,102,7,5}}; SetGhostElementsI(20);

      /* octahedron 3 */  
      cell4[21] = (z4_t){{103,9,2,5}}; SetGhostElementsS(21);
      cell4[22] = (z4_t){{103,9,5,4}}; SetGhostElementsS(22);
      cell4[23] = (z4_t){{103,9,4,1}}; SetGhostElementsS(23);
      cell4[24] = (z4_t){{103,9,1,2}}; SetGhostElementsS(24);
      cell4[25] = (z4_t){{0,103,2,5}}; SetGhostElementsI(25);
      cell4[26] = (z4_t){{0,103,5,4}}; SetGhostElementsI(26);
      cell4[27] = (z4_t){{0,103,4,1}}; SetGhostElementsI(27);
      cell4[28] = (z4_t){{0,103,1,2}}; SetGhostElementsI(28);

      /* octahedron 4 */ 
      cell4[29] = (z4_t){{104,9,2,1}}; SetGhostElementsS(29);
      cell4[30] = (z4_t){{104,9,1,8}}; SetGhostElementsS(30);
      cell4[31] = (z4_t){{104,9,8,7}}; SetGhostElementsS(31);
      cell4[32] = (z4_t){{104,9,7,2}}; SetGhostElementsS(32);
      cell4[33] = (z4_t){{3,104,2,1}}; SetGhostElementsI(33);
      cell4[34] = (z4_t){{3,104,1,8}}; SetGhostElementsI(34);
      cell4[35] = (z4_t){{3,104,8,7}}; SetGhostElementsI(35);
      cell4[36] = (z4_t){{3,104,7,2}}; SetGhostElementsI(36);

      /* octahedron 5 */ 
      cell4[37] = (z4_t){{105,1,0,4}}; SetGhostElementsS(37);
      cell4[38] = (z4_t){{105,1,4,8}}; SetGhostElementsS(38);
      cell4[39] = (z4_t){{105,1,8,3}}; SetGhostElementsS(39);
      cell4[40] = (z4_t){{105,1,3,0}}; SetGhostElementsS(40);
      cell4[41] = (z4_t){{6,105,0,4}}; SetGhostElementsI(41);
      cell4[42] = (z4_t){{6,105,4,8}}; SetGhostElementsI(42);
      cell4[43] = (z4_t){{6,105,8,3}}; SetGhostElementsI(43);
      cell4[44] = (z4_t){{6,105,3,0}}; SetGhostElementsI(44);
        
        
      /* set the labels for each tetrahedra */
      for (i = 0; i < cellnum; i++)
      {
        SetCornersTetra(i,cell4[i]);
      }

      /* builds the table of walls for choose which tetrahedra
          must be gluing.
      */

      if (o->detail)
      {
        fprintf(stderr, "C  id      table     wall\n");
        fprintf(stderr, "-------------------------\n");
      }

      for (i = 0; i < cellnum; i++)
      {
        if (o->detail)
        {
          fprintf(stderr, Fmt.Int(i) & "\n");
        }
        for (k = 0; k < 4; k++)
        {
          walls[(4*i)+k] = tetra[i].p[k];
          if (o->detail)
          {
            fprintf(stderr," "& Fmt.Pad(Fmt.Int(id),4)&"   "); id++;
            PrintCorners((4*i)+k);
            fprintf(stderr, "   " & Fmt.Int(k) & "\n");
          }
        }
      }
                
      /* computing which cells must be gluing. */               
      for(k = 0; k < walls.nel; k++)
      {
        for (l = k+1 TO LAST(walls^))
        {
          for (m = 0; m < 3; m++)
          {
            ??? e = NextEK(walls[l],m);
            with (
          ){
              if ((MustBeGlued(walls[k],e)))
              {
                if (o->detail)
                {
                  fprintf(stderr, Fmt.Int(count) & "\n");
                  fprintf(stderr, "must be gluing: walls[" & Fmt.Int(k) \
                    "] with ");
                  fprintf(stderr, "walls[" & Fmt.Int(l) &"]\n");
                }
                ??? kc = k % 4;
                ??? kt = k DIV 4;
                ??? lc = l % 4;
                ??? lt = l DIV 4;
                {
                  if (o->detail)
                  {
                    fprintf(stderr, "  tetra["&Fmt.Int(kt) & "," \
                      Fmt.Int(kc) & "] and tetra[" & Fmt.Int(lt) & "," \
                      Fmt.Int(lc) & "]\n\n");
                  } 
                  glues[count-1] = (z4_t){{kt,lt,kc,lc}};
                  count++;
                  if ((BadAttribution(walls[k],e)))
                  {
                    fprintf(stderr, "Bad Attribution " & "  tetra["&
                      Fmt.Int(kt) &"and tetra[" & Fmt.Int(lt) & "]\n");
                  }
                }
              }      
            }
          }   
        }
      }
       
      /* Do the automatic gluing of tetrahedra */
     for (i = 0; i < 2*cellnum; i++)
     {
       ??? c = glues[i];
       {
         EVAL GlueTetras(c[0],c[1],c[2],c[3]);
       }
     }

     /* Set the origins. */
     for (i = 0; i < cellnum; i++)
     {
       for (j = 0; j < 4; j++)
       {
         ??? a = tetra[i].p[j];
         with (
         double b = NextE(a);
         double c = PrevE(a)
        ){
           SetOrgAll(a,OrgV(a));
           SetOrgAll(b,OrgV(b));
           SetOrgAll(c,OrgV(c));
         }
       }
     }

     /* Builds and writes the topology. */
     
     fprintf(stderr, "Building the topology of pentaocta:\n");
       
     ??? a = tetra[44;
       with (0],
     double top = MakeElemTable(a);
     double c = GenCoords(top)^;
     double shapeName = "pentaocta"
   ){
       /* seting the elements root for edges and walls.*/
       for (i = 0; i < top.wall.nel; i++)
       {
         ??? f = top.wall[i];
         {  
           f->root = f->num;
         }
       }

       for (i = 0; i < top.edge.nel; i++)
       {
         ??? e = top.edge[i];
         {  
           e->root = e->num;
         }
       }

       /* test for the original elements */
       VAR nve,nee,nfe: uint = 0;
       {
         for (i = 0; i < top.node.nel; i++)
         {
           ??? v = top.node[i];
           {
             if (v->exists){ nve++; }
           }
         }
         for (i = 0; i < top.edge.nel; i++)
         {
           ??? e = top.edge[i];
           {
             if (e->exists){ nee++; }
           }
         }
         for (i = 0; i < top.wall.nel; i++)
         {
           ??? f = top.wall[i];
           {
             if (f->exists){ nfe++; }
           }
         }
         assert(nve == 10);
         assert(nee == 30);
         assert(nfe == 30);
       }

       WriteTopology(shapeName, top,
         "Created by MakePentaOcta: " & shapeName & ".tp  on " \
         Today());

       WriteMaterials(shapeName, top,
         "Created by MakePentaOcta: " & shapeName & ".ma  on " \
         Today());

       WriteState(shapeName, top, c,
         "Created by MakePentaOcta: " & shapeName & ".st on " \
         Today() &"\nRandom Geometry"); 
     }  
} DoIt;

/* UNUSED */
PROCEDURE PrintRow4I(m: z4_t)
  /* Print an array of four integer values. */
  
  { fprintf(stderr,Fmt.Int(m[0]) & " " & Fmt.Int(m[1]) & " " \
       Fmt.Int(m[2]) & " " & Fmt.Int(m[3]) & "\n");
  } /* END PrintRow4I */       

/* UNUSED */
PROCEDURE PrintRow2I(m: Row2I)
  /* Print an array of two integer values. */
  
  { fprintf(stderr,Fmt.Int(m[0]) & " " & Fmt.Int(m[1]) & "\n");
  } /* END PrintRow2I */      

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);
    {
      ¦TRY

        o->detail = argparser_keyword_present(pp, "-detail");
        argparser_finish(pp);                                       
      
  -----------------------------------
#define _HELP \
  fprintf(stderr, "Usage: MakePentaOcta [ -detail ] \n");
          
END¦                                              
      }
    }
    return o;
  } /* END GetOptions */

{
  DoIt()
} MakePentaOcta.


  /* Copyright © 2000     Universidade Estadual de Campinas (UNICAMP)     */