CoCalc -- bravais

GAP 4.8.9 installation with standard packages -- copy to your CoCalc project to get it
gap4r8 / pkg / carat / carat-2.1b1 / functions / Idem / bravais_catalog.c
⁵⁶³⁵⁹⁶ views
1
#include"typedef.h"
2
#include"idem.h"
3
#include"longtools.h"
4
#include"getput.h"
5
#include"voronoi.h"
6
#include"bravais.h"
7
#include"datei.h"
8
#include"matrix.h"
9
#include"orbit.h"
10
#include"tools.h"
11
#include"reduction.h"
12

13
extern int INFO_LEVEL;
14
/*****************************************************************************
15
@
16
@-----------------------------------------------------------------------------
17
@ FILE: bravais_catalog.c
18
@-----------------------------------------------------------------------------
19
@
20
*****************************************************************************/
21

22
symbol_out *read_symbol_from_string(symb)
23
char *symb;
24
{
25
char  string[80],
26
      slash, *str ;
27
char f[80];
28
char *fn;
29
char *dat;
30
int     i, j, k, l, m, n, p, q, x, groesser;
31
int len;
32
int no;
33
int breite;
34
char merk[15];
35
char merk1[10];
36
int index;
37
char konst[MAXDIM][80];
38
int konst_dim;
39
int komp[MAXDIM];
40
int artgleich[MAXDIM];
41
int dim = 0, konstit = 0;
42
int zerleg[MAXDIM][5];
43
bravais_TYP **grps;
44
symbol_out *erg;
45
matrix_TYP *In;
46

47
fn = (char *) malloc(1024 * sizeof(char));
48

49
for (i=0;i<80;i++) string[i] = 0;
50

51
for( i=0; i<MAXDIM; i++)
52
  komp[i] = 0;
53
for(i=0; i<MAXDIM; i++)
54
  for(j=0; j<5;j++)
55
    zerleg[i][j] = 0;
56

57
/* inserted tilman 05/08/97 */
58
sprintf(string,"%s",symb);
59
right_order(string);
60

61
str = string;
62
len = strlen(str);
63
while( len > 0 )
64
{
65
  i = strcspn(str, ";,");
66
  if(i>0)
67
  {
68
    sscanf(str, "%d", &konst_dim);
69
    dim += konst_dim;
70
    if(dim > MAXDIM)
71
    {
72
       printf("dimension of a.d. bravais-group is to big\n");
73
       exit(3);
74
    }
75
    zerleg[konstit][0] = konst_dim;
76
    itoa(konst_dim, konst[konstit]);
77
    k = strcspn(str, ";");
78
    if(k == i)
79
      zerleg[konstit][3] = 1;
80
    j = strcspn(str, "-");
81
    l = strcspn(str, "'");
82
    if(j<i)
83
    {
84
       strcat(konst[konstit], "-");
85
       str = str+j+1;
86
       len = len-j-1;
87
       sscanf(str, "%d", &index);
88
       zerleg[konstit][1] = index;
89
       itoa(index, merk);
90
       strcat(konst[konstit], merk);
91
       memset(merk,'\0',strlen(merk));
92
       if(l<i)
93
       {
94
         strcat(konst[konstit], "'");
95
         zerleg[konstit][2] = 1;
96
       }
97
       i = i-j-1;
98
    }
99
    konstit++;
100
  }
101
  str = str+i+1;
102
  len = len-i-1;
103
}
104

105
erg = (symbol_out *) malloc(sizeof(symbol_out));
106
erg->grp = (bravais_TYP *) calloc(1, sizeof(bravais_TYP));
107
erg->grp->dim = dim;
108

109
/*--------------------------------------------------------------------*\
110
|  swap the atoms into the right order                                 |
111
\*--------------------------------------------------------------------*/
112
for(i=0; i<MAXDIM-1; i++)
113
{
114
  if(zerleg[i][0] != zerleg[i+1][0] || zerleg[i][1] != zerleg[i+1][1] || zerleg[i][2]  != zerleg[i+1][2])
115
    zerleg[i][3] = 1;
116
}
117
if(zerleg[MAXDIM-1][0] != 0)
118
  zerleg[MAXDIM-1][3] = 1;
119
i=0;
120
while(i<MAXDIM)
121
{
122
  while( i< MAXDIM && zerleg[i][0] == 0)
123
    i++;
124
  k = 1;
125
  while(i<MAXDIM && zerleg[i][3] == 0 && zerleg[i][0] != 0)
126
  {  i++; k++;}
127
  if(i != MAXDIM)
128
    zerleg[i][4] = k;
129
  i++;
130
}
131
for(i=0; i<MAXDIM; i++)
132
{
133
  for(j=i+1; j<MAXDIM; j++)
134
  {
135
    groesser = 1;
136
    if(zerleg[i][4] == 0 && zerleg[j][4] != 0)
137
       groesser = 0;
138
    for(k=0; k<3 && zerleg[j][k] == zerleg[i][k]; k++);
139
    if(k == 0 && zerleg[i][k] < zerleg[j][k])
140
      groesser = 0;
141
    if(k == 1 && zerleg[i][1] > zerleg[j][1])
142
      groesser = 0;
143
    if(k == 2 && zerleg[i][2] < zerleg[j][2])
144
      groesser = 0;
145
    if(k == 3 && zerleg[i][4] < zerleg[j][4])
146
      groesser = 0;
147
    if(groesser == 0)
148
    {
149
      for(k=0; k<5; k++)
150
      {
151
         x = zerleg[i][k]; zerleg[i][k] = zerleg[j][k]; zerleg[j][k] = x;
152
      }
153
    }
154
  } 
155
}
156
/************************
157
for(i=0; i<konstit; i++)
158
{
159
  for(j=0; j<5; j++)
160
     printf("%d ", zerleg[i][j]);
161
  printf("\n");
162
}
163
*************************/
164

165
konstit = 0;
166
for(i=0; i<MAXDIM; i++)
167
{
168
  if(zerleg[i][4] != 0)
169
  {
170
    itoa(zerleg[i][0], konst[konstit]);
171
    if(zerleg[i][1] != 0)
172
    {
173
       strcat(konst[konstit], "-");
174
       itoa(zerleg[i][1], merk);
175
       strcat(konst[konstit], merk);
176
       memset(merk,'\0',strlen(merk));
177
       if(zerleg[i][2] != 0)
178
         strcat(konst[konstit], "\'");
179
    }
180
    konstit++;
181
  }
182
}
183

184
/*--------------------------------------------------------------------*\
185
|  read the atoms                                                      |
186
\*--------------------------------------------------------------------*/
187
grps = (bravais_TYP **) malloc(konstit *sizeof(bravais_TYP *));
188
dat = ATOMS;
189
/**************
190
dat = TOPDIR "/lib/atoms/";
191
f = (char **) malloc(konstit *sizeof(char *));
192
***************/
193
for(i=0; i<konstit; i++)
194
{
195
   strcpy(f, dat);
196
   itoa(zerleg[i][0], merk);
197
   strcat(f, merk);
198
   if(zerleg[i][1] != 0)
199
   {
200
     strcat(f, "-");
201
     itoa(zerleg[i][1], merk);
202
     strcat(f, merk);
203
     memset(merk,'\0',strlen(merk));
204
   }
205
   if(zerleg[i][2] != 0)
206
   {
207
     strcat(f, "\'");
208
   }    
209
   if (INFO_LEVEL & 4) fprintf(stderr,"file-name: %s\n",f);
210
   grps[i] = get_bravais(f);
211
   for(j=0; j<grps[i]->form_no; j++)
212
     Check_mat(grps[i]->form[j]);
213
}
214

215
/*--------------------------------------------------------------------*\
216
|  calculate the generators of erg->grp                                |
217
\*--------------------------------------------------------------------*/
218
erg->grp->gen_no = 0;
219
erg->grp->form_no = 0;
220
erg->grp->zentr_no = 0;
221
erg->grp->normal_no = 0;
222
for(i=0; i<konstit; i++)
223
  erg->grp->gen_no += grps[i]->gen_no;
224
erg->grp->gen = (matrix_TYP **)malloc(erg->grp->gen_no *sizeof(matrix_TYP));
225
for(i=0; i<erg->grp->gen_no; i++)
226
  erg->grp->gen[i]  = init_mat(erg->grp->dim, erg->grp->dim, "");
227
j=0;
228
p=0;
229
for(i=0; i<konstit; i++)
230
{
231
 for(k=0; k<grps[i]->gen_no; k++)
232
 {
233
  for(l=0; l<zerleg[i][4] * grps[i]->dim; l += grps[i]->dim)
234
  {
235
   for(m=0; m<grps[i]->dim; m++)
236
    for(n=0; n<grps[i]->dim; n++)
237
     erg->grp->gen[p+k]->array.SZ[j+l+m][j+l+n]=grps[i]->gen[k]->array.SZ[m][n];
238
  }
239
  for(m=0; m<j; m++)
240
     erg->grp->gen[p+k]->array.SZ[m][m] = 1;
241
  for(m=( j + zerleg[i][4] * grps[i]->dim); m<erg->grp->dim; m++)
242
     erg->grp->gen[p+k]->array.SZ[m][m] = 1;
243
 }
244
   j = j + zerleg[i][4] * grps[i]->dim; 
245
   p = p + grps[i]->gen_no;
246
}
247

248
/*--------------------------------------------------------------------*\
249
|  calculate the invariant forms of erg->grp                           |
250
\*--------------------------------------------------------------------*/
251
for(i=0; i<konstit; i++)
252
{
253
  for(j=0; j<grps[i]->form_no; j++)
254
  {
255
     if(grps[i]->form[j]->flags.Symmetric == TRUE)
256
        erg->grp->form_no += (zerleg[i][4] * (zerleg[i][4] +1)/2);
257
     if(grps[i]->form[j]->flags.Symmetric == FALSE)
258
        erg->grp->form_no += (zerleg[i][4] * (zerleg[i][4] -1)/2);
259
  }
260
}
261
erg->grp->form = (matrix_TYP **)malloc(erg->grp->form_no *sizeof(matrix_TYP *));
262
for(i=0; i<erg->grp->form_no; i++)
263
  erg->grp->form[i]  = init_mat(erg->grp->dim, erg->grp->dim, "");
264
j=0;
265
q=0;
266
for(i=0; i<konstit; i++)
267
{
268
 for(k=0; k<grps[i]->form_no; k++)
269
 {
270
  for(l=j; l< j+zerleg[i][4] * grps[i]->dim; l += grps[i]->dim)
271
  {
272
   if(grps[i]->form[k]->flags.Symmetric == TRUE)
273
   {
274
    for(n=0; n<grps[i]->dim; n++) 
275
    {
276
     for(p=0; p<grps[i]->dim; p++)
277
     {
278
       erg->grp->form[q]->array.SZ[l+n][l+p] = grps[i]->form[k]->array.SZ[n][p];
279
     }
280
    }
281
    q++;
282
   }
283
   for(m=(l+grps[i]->dim); m<(j+zerleg[i][4] * grps[i]->dim); m +=grps[i]->dim)
284
   {
285
    for(n=0; n<grps[i]->dim; n++) 
286
    {
287
     for(p=0; p<grps[i]->dim; p++)
288
     {
289
       erg->grp->form[q]->array.SZ[l+n][m+p] = grps[i]->form[k]->array.SZ[n][p];
290
       erg->grp->form[q]->array.SZ[m+p][l+n] = grps[i]->form[k]->array.SZ[n][p];
291
     }
292
    }
293
    q++;
294
   }
295
  }
296
 }
297
 j = j + zerleg[i][4] * grps[i]->dim; 
298
}
299
/* assure that the full integral lattice is passed */
300
long_rein_formspace(erg->grp->form,erg->grp->form_no,1);
301

302
/*--------------------------------------------------------------------*\
303
| calculate the centralizer of the group                               |
304
\*--------------------------------------------------------------------*/
305
for(i=0; i<konstit; i++)
306
{
307
  erg->grp->cen_no = erg->grp->cen_no + grps[i]->cen_no;
308
  if(zerleg[i][4] >= 2)
309
    erg->grp->cen_no = erg->grp->cen_no + grps[i]->zentr_no + 1;
310
  if(zerleg[i][4] > 2)
311
    erg->grp->cen_no ++;
312
}
313
erg->grp->cen = (matrix_TYP **)malloc(erg->grp->cen_no *sizeof(matrix_TYP));
314
for(i=0; i<erg->grp->cen_no; i++)
315
  erg->grp->cen[i]  = init_mat(erg->grp->dim, erg->grp->dim, "");
316
j=0;
317
no = 0;
318
for(i=0; i<konstit; i++)
319
{
320
   for(k=0; k<grps[i]->cen_no; k++)
321
   {
322
     for(l=0; l<j; l++)
323
       erg->grp->cen[no]->array.SZ[l][l] = 1;
324
     for(l=j+grps[i]->dim; l<erg->grp->dim; l++)
325
       erg->grp->cen[no]->array.SZ[l][l] = 1;
326
     for(l=0; l<grps[i]->dim; l++)
327
       for(m=0; m<grps[i]->dim; m++)
328
        erg->grp->cen[no]->array.SZ[j+l][j+m] = grps[i]->cen[k]->array.SZ[l][m];
329
     no++;
330
   }
331
   if(zerleg[i][4] >=2)
332
   {
333
     for(k=0; k<grps[i]->zentr_no; k++)
334
     {
335
       for(l=0; l<j; l++)
336
         erg->grp->cen[no]->array.SZ[l][l] = 1;
337
       for(l=j; l<j+grps[i]->dim; l++)
338
         erg->grp->cen[no]->array.SZ[l][l] = -1;
339
       for(l=j+grps[i]->dim; l<erg->grp->dim; l++)
340
         erg->grp->cen[no]->array.SZ[l][l] = 1;
341
       for(l=0; l<grps[i]->dim; l++)
342
          for(m=0; m<grps[i]->dim; m++)
343
            erg->grp->cen[no]->array.SZ[j+l+grps[i]->dim][j+m] = grps[i]->zentr[k]->array.SZ[l][m];
344
       no++;
345
     }
346
       for(l=0; l<j; l++)
347
         erg->grp->cen[no]->array.SZ[l][l] = 1;
348
       for(l=j+(2 * grps[i]->dim); l<erg->grp->dim; l++)
349
         erg->grp->cen[no]->array.SZ[l][l] = 1;
350
       for(l=0; l<grps[i]->dim; l++)
351
       {
352
          erg->grp->cen[no]->array.SZ[j+l+grps[i]->dim][j+l] = 1;
353
          erg->grp->cen[no]->array.SZ[j+l][j+l+grps[i]->dim] = 1;
354
       }
355
       no++;
356
   }
357
   if(zerleg[i][4] > 2)
358
   {
359
       for(l=0; l<j; l++)
360
         erg->grp->cen[no]->array.SZ[l][l] = 1;
361
       for(l=j+(zerleg[i][4] * grps[i]->dim); l<erg->grp->dim; l++)
362
         erg->grp->cen[no]->array.SZ[l][l] = 1;
363
       for(l=0; l< ((zerleg[i][4] -1) * grps[i]->dim); l++)
364
          erg->grp->cen[no]->array.SZ[l+j+grps[i]->dim][l+j] = 1;
365
       for(l=0; l<grps[i]->dim; l++)
366
         erg->grp->cen[no]->array.SZ[j+l][l+j+((zerleg[i][4]-1) * grps[i]->dim)] = 1;
367
     no++;
368
   }
369
   
370
   j = j + zerleg[i][4] * grps[i]->dim; 
371
}
372

373
/*--------------------------------------------------------------------*\
374
| calculate the normalizer of the group                               |
375
\*--------------------------------------------------------------------*/
376

377
for(i=0; i<konstit; i++)
378
{
379
        artgleich[i] = 0;
380
        erg->grp->normal_no += grps[i]->normal_no;
381
        if(i+1 < konstit)
382
        {
383
          if(zerleg[i][0] == zerleg[i+1][0] && zerleg[i][1] == zerleg[i+1][1] &&
384
             zerleg[i][2] == zerleg[i+1][2] && zerleg[i][3] == zerleg[i+1][3] &&
385
             zerleg[i][4] == zerleg[i+1][4])
386
          {
387
             artgleich[i] = TRUE;
388
             erg->grp->normal_no++;
389
          }
390
        }
391
}
392

393
if (erg->grp->normal_no > 0)
394
   erg->grp->normal = (matrix_TYP **) malloc(erg->grp->normal_no
395
                                            * sizeof(matrix_TYP));
396
else
397
   erg->grp->normal = NULL;
398

399
for(i=0; i<erg->grp->normal_no; i++)
400
  erg->grp->normal[i]  = init_mat(erg->grp->dim, erg->grp->dim, "");
401
j=0;
402
no = 0;
403
for(i=0; i<konstit; i++)
404
{
405
   for(k=0; k<grps[i]->normal_no; k++)
406
   {
407
      for(l=0; l<j;l++)
408
        erg->grp->normal[no]->array.SZ[l][l] = 1;
409
      for(l=(j+zerleg[i][4] * grps[i]->dim); l<erg->grp->dim; l++)
410
        erg->grp->normal[no]->array.SZ[l][l] = 1;
411
      for(l=j; l< (j+zerleg[i][4] * grps[i]->dim); l += grps[i]->dim)
412
      {
413
         for(m=0; m<grps[i]->dim; m++)
414
           for(p=0; p<grps[i]->dim; p++)
415
         erg->grp->normal[no]->array.SZ[m+l][p+l] = grps[i]->normal[k]->array.SZ[m][p];
416
      }
417
      no++;
418
   }
419
   if(artgleich[i] == TRUE)
420
   {
421
     breite = grps[i]->dim * zerleg[i][4];
422
     for(l=0; l<j; l++)
423
       erg->grp->normal[no]->array.SZ[l][l] = 1;
424
     for(l=(j + 2 * breite); l<erg->grp->dim; l++)
425
       erg->grp->normal[no]->array.SZ[l][l] = 1;
426
     for(l=j; l< (j+breite); l++)
427
     {
428
       erg->grp->normal[no]->array.SZ[l][l+breite] = 1;
429
       erg->grp->normal[no]->array.SZ[l+breite][l] = 1;
430
     }
431
     no++;
432
   }
433
   j = j + zerleg[i][4] * grps[i]->dim; 
434
}
435

436
/*--------------------------------------------------------------------*\
437
| if no additional normalizer or centraliser nessecarry, put identity  |
438
\*--------------------------------------------------------------------*/
439
if(erg->grp->normal_no == 0 || erg->grp->cen_no == 0)
440
{
441
  if(erg->grp->normal_no == 0)
442
  {
443
     erg->grp->normal_no = 1;
444
     erg->grp->normal = (matrix_TYP **) malloc(1 *sizeof(matrix_TYP *));
445
     erg->grp->normal[0] = einheitsmatrix(erg->grp->dim);
446
  }
447
  if(erg->grp->cen_no == 0)
448
  {
449
     erg->grp->cen_no = 1;
450
     erg->grp->cen = (matrix_TYP **) malloc(1 *sizeof(matrix_TYP *));
451
     erg->grp->cen[0] = einheitsmatrix(erg->grp->dim);
452
  }
453
}
454

455
/*--------------------------------------------------------------------*\
456
| calculate the order of erg->grp                                      |
457
\*--------------------------------------------------------------------*/
458
for(j=0; j<100; j++)
459
  erg->grp->divisors[j] = 0;
460
erg->grp->order = 1;
461
for(i=0; i<konstit; i++)
462
{
463
  for(j=0; j<100; j++)
464
    erg->grp->divisors[j] += grps[i]->divisors[j];
465
  erg->grp->order *= grps[i]->order;
466
}
467

468
/*--------------------------------------------------------------------*\
469
| find file where erg->grp->zentr are stored                           |
470
\*--------------------------------------------------------------------*/
471
strcpy(fn, TABLEDIM);
472
/*********************************
473
strcpy(fn, TOPDIR "/lib/dim");
474
*********************************/
475
itoa(erg->grp->dim, merk);
476
strcat(fn, merk);
477
strcat(fn, "/");
478
for(i=0; i<konstit; i++)
479
{
480
  itoa(zerleg[i][0], merk);
481
  if(zerleg[i][1] != 0)
482
  {
483
    strcat(merk, "-");
484
    itoa(zerleg[i][1], merk1);
485
    strcat(merk, merk1);
486
  }
487
  if(zerleg[i][2] != 0)
488
    strcat(merk, "\'");
489
  for(j=0; j<zerleg[i][4]; j++)
490
  {
491
    strcat(fn, merk);
492
    if(j != (zerleg[i][4] -1))
493
      strcat(fn, ",");
494
    else
495
    {
496
      if(i!= (konstit -1))
497
        strcat(fn, ";");
498
    }
499
  }
500
}
501
erg->fn = fn;
502

503
if (INFO_LEVEL & 4) printf("%s\n", erg->fn);
504

505
 /* clear the atoms */
506
 for (i=0;i<konstit;i++) free_bravais(grps[i]);
507
 free(grps);
508

509
 return(erg);
510
}
511

512
/****************************************************************************
513
@
514
@------------------------------------------------------------------------------
515
@
516
@ bravais_TYP *catalog_number(bravais_TYP *G,char *symb,
517
@                             matrix_TYP **TR,int *almost,int *zclass)
518
@
519
@ The function searches for a Bravais group Z-equivalent to G in the
520
@ catalog. It will return this group, a transformation matrix via TR[0],
521
@ and the coordinates of the group in the catalog via almost[0], zclass[0].
522
@
523
@ It will return a transfromation matrix via TR[0], and the position
524
@ in the catalog via almost[0] and zclass[0].
525
@
526
@ bravais_TYP *G : The group in question. Its order must be given.
527
@ char *symb     : The symbol of the group. It can be calculated via symbol(..)
528
@ matrix_TYP **TR: pointer for the transformation matrix which transforms
529
@                  the given group G to the group returned via konj_bravais,
530
@                  ie. TR[0]  * G * TR[0]^-1 = group returned.
531
@ int *almost    : the position of the almost decomposable group in the
532
@                  catalog is returned via this pointer.
533
@ int *zclass    : 2 coordinate of the group in the catalog.
534
@
535
@------------------------------------------------------------------------------
536
@
537
*****************************************************************************/
538
bravais_TYP *catalog_number(bravais_TYP *G,char *symb,
539
                            matrix_TYP **TR,int *almost,int *zclass)
540
{
541

542
   bravais_TYP *T = NULL,
543
               *Gneu,     /* the bravais group G written in a better basis */
544
               *Gtr,      /* transposed of Gneu */
545
               *H,        /* H is the pointer where a group read from the
546
                             catalog is stored */
547
               *Htr;      /* transposed of H */
548

549
   symbol_out *S;
550

551
   matrix_TYP *X,          /* strictly speeking not needed, just to
552
                              avoid writting TR[0] all the time */
553
              *F,          /* a positive definite form for reducing G */
554
              *B,          /* a new, good basis for G */
555
              *BI;         /* the inverse of B */
556

557
   char *file;
558

559
   int i,
560
       anz_gperfect=0;
561

562
   voronoi_TYP **gp=NULL;     /* holds the voronoi data for Gneu. Therefore
563
                                 we will only calculate it once */
564

565
   if (G->dim > MAXDIM){
566
      fprintf(stderr,"This program does only work up to dimension %d\n",
567
                      MAXDIM);
568
      exit(3);
569
   }
570

571
   /* deal with the v_4 part in a different function */
572
   /* it returns T != NULL iff the group was isomorphic to V_4
573
      or C_2 = <-I_n>. In this case everything has been done */
574
   /* T = catalog_number_v4(G,symb,TR,almost,zclass); */
575
   T = NULL;
576

577
   if (T==NULL){
578

579
      /* inserted tilman 6/08/97, choose a better basis */
580
      B = init_mat(G->dim,G->dim,"1");
581
      F = rform(G->gen,G->gen_no,B,101);
582
      BI = pair_red(F,B);
583
      free_mat(BI);
584
      free_mat(F);
585
      BI = tr_pose(B);
586
      free_mat(B);
587
      B = BI;
588
      BI = long_mat_inv(B);
589
      Gneu = konj_bravais(G,BI);
590

591
      /* choose a good basis for the space of fixed forms of Gneu */
592
      long_rein_formspace(Gneu->form,Gneu->form_no,1);
593

594
      /* initialize */
595
      almost[0] = 0;
596
      S = read_symbol_from_string(symb);
597
      get_zentr(S);
598
      Gtr = tr_bravais(Gneu,1,FALSE);
599

600
      while (T == NULL && S != NULL){
601
         almost[0]++;
602
         zclass[0] = -1;
603
         while (T == NULL && (zclass[0] < S->grp->zentr_no )){
604
            if (zclass[0] == -1){
605
               H = S->grp;
606

607
               /* throw away the normalizer & centralizer, it only hinders
608
                  calculation */
609
               for (i=0;i<H->cen_no;i++) free_mat(H->cen[i]);
610
               if (H->cen != NULL && H->cen_no > 0)
611
                  free(H->cen);
612
               H->cen_no = 0;
613
               H->cen = NULL;
614
               for (i=0;i<H->normal_no;i++) free_mat(H->normal[i]);
615
               if (H->normal != NULL && H->normal_no > 0)
616
                  free(H->normal);
617
               H->normal_no = 0;
618
               H->normal = NULL;
619
            }
620
            else{
621
               H = Z_class(S->grp,S->grp->zentr[zclass[0]]);
622
            }
623

624
            if (Gneu->order == 0 ||
625
               (Gneu->order == H->order)){
626
                Htr = tr_bravais(H,1,FALSE);
627
                X = is_z_equivalent_datei(Gneu,Gtr,H,Htr,&gp,&anz_gperfect);
628
                free_bravais(Htr);
629
            }
630
            else{
631
               X = NULL;
632
            }
633

634
            if (X == NULL && zclass[0] != -1){
635
               free_bravais(H);
636
            }
637
            else if (X!=NULL) {
638
               T = H;
639
               TR[0] = X;
640
            }
641
            zclass[0]++;
642
         }
643

644
         if (zclass[0] > 0 || T == NULL) free_bravais(S->grp);
645
         file = S->fn;
646
         free(S);
647

648
         /* get the next almost decomposable group if necessary */
649
         if (T == NULL){
650

651
            /* there might be the case that we dealt with all groups in the
652
            catalog, but we didn't find an appropriate one */
653
            if (file == NULL){
654
               fprintf(stderr,"An error occured: This bravais group is not\n");
655
               fprintf(stderr,"in the catalog.\n");
656
               fprintf(stderr,"Please report this to\n");
657
               fprintf(stderr,"   [email protected]\n");
658
               fprintf(stderr,"immediately, with a copy of your input file and\n");
659
               fprintf(stderr,"this message. (And the bravais group echoed to\n");
660
               fprintf(stderr,"stdout now)\n");
661
               put_bravais(G,NULL,"ERROR IN: catalog_number");
662
               exit(3);
663
            }
664
            S = get_symbol(file);
665
         }
666

667
         if (file != NULL) free(file);
668
      }
669

670
      /* we started with -1, so we have to correct this "error" */
671
      zclass[0]++;
672

673
      /* free the voronoi data for Gneu */
674
      for (i=0;i<anz_gperfect;i++){
675
         clear_voronoi(gp[i]);
676
         free(gp[i]);
677
      }
678
      free(gp);
679

680
      /* adjust the transformations matrix */
681
      /* i.e replace TR[0] by TR[0]*BI */
682
      mat_muleq(TR[0],BI);
683

684
      free_bravais(Gtr);
685
      free_bravais(Gneu);
686
      free_mat(B);
687
      free_mat(BI);
688
   }
689

690
   return T;
691

692
}
693

694
Product

Resources

Company
