software/meankondo
1
Fork 0
Code Issues Pull Requests Releases Activity
meankondo/src/kondo.c
Ian Jauslin f13eacbc8e Support for non-commuting fields
2015-07-22 13:55:29 +00:00

1450 lines
35 KiB
C
Raw Blame History

/*
Copyright 2015 Ian Jauslin
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
#include "kondo.h"
#include <stdlib.h>
#include <stdio.h>
#include "idtable.h"
#include "array.h"
#include "number.h"
#include "istring.h"
#include "cli_parser.h"
#include "fields.h"
#include "parse_file.h"
#include "polynomial.h"
#include "definitions.cpp"
#include "rational.h"
// dimension of A, B, h and t (must be <10)
#define KONDO_DIM 3
// number of spin components
#define KONDO_SPIN 2
// offsets for indices of A, B, h and t
// order matters for symbols table
#define KONDO_A_OFFSET 1
#define KONDO_B_OFFSET 2
#define KONDO_H_OFFSET 3
#define KONDO_T_OFFSET 4
// parsing modes (from parse_file.c)
#define PP_NULL_MODE 0
// when reading a factor
#define PP_FACTOR_MODE 1
// reading a monomial
#define PP_MONOMIAL_MODE 2
// reading a numerator and denominator
#define PP_NUMBER_MODE 3
// types of fields
#define PP_FIELD_MODE 6
#define PP_PARAMETER_MODE 7
#define PP_EXTERNAL_MODE 8
#define PP_INTERNAL_MODE 9
// indices
#define PP_INDEX_MODE 10
// factors or monomials
#define PP_BRACKET_MODE 11
// labels
#define PP_LABEL_MODE 12
// polynomial
#define PP_POLYNOMIAL_MODE 13
// field scalar product
#define PP_FIELD_SCALAR_MODE 14
#define PP_FIELD_VECTOR_PROD_MODE 15
// generate configuration file
int kondo_generate_conf(Str_Array* str_args, int box_count){
Str_Array new_args;
Fields_Table fields;
Char_Array tmp_str;
int arg_index;
int i;
Char_Array title;
init_Str_Array(&new_args,8);
// fields
kondo_fields_table(box_count, &tmp_str, &fields);
str_array_append_noinit(tmp_str, &new_args);
// symbols
kondo_symbols(&tmp_str, box_count, &fields);
arg_index=find_str_arg("symbols", *str_args);
if(arg_index>=0){
if(tmp_str.length>0){
char_array_snprintf(&tmp_str,",\n");
}
char_array_concat((*str_args).strs[arg_index], &tmp_str);
}
parse_input_symbols(tmp_str, &fields);
str_array_append_noinit(tmp_str, &new_args);
// identities
kondo_identities(&tmp_str);
arg_index=find_str_arg("identities", *str_args);
if(arg_index>=0){
if(tmp_str.length>0){
char_array_snprintf(&tmp_str,",\n");
}
char_array_concat((*str_args).strs[arg_index], &tmp_str);
}
parse_input_identities(tmp_str, &fields);
str_array_append_noinit(tmp_str, &new_args);
// groups
kondo_groups(&tmp_str, box_count);
str_array_append_noinit(tmp_str, &new_args);
// propagator
arg_index=find_str_arg("propagator", *str_args);
if(arg_index>=0){
kondo_propagator((*str_args).strs[arg_index], &tmp_str);
str_array_append_noinit(tmp_str, &new_args);
}
// input polynomial
arg_index=find_str_arg("input_polynomial", *str_args);
if(arg_index>=0){
kondo_input_polynomial((*str_args).strs[arg_index], &tmp_str, fields, box_count);
str_array_append_noinit(tmp_str, &new_args);
}
// id table
arg_index=find_str_arg("id_table", *str_args);
if(arg_index>=0){
kondo_idtable((*str_args).strs[arg_index], &tmp_str, fields);
str_array_append_noinit(tmp_str, &new_args);
}
// copy remaining entries
for(i=0;i<(*str_args).length;i++){
get_str_arg_title((*str_args).strs[i], &title);
if(str_cmp(title.str, "symbols")==0 &&\
str_cmp(title.str, "identities")==0 &&\
str_cmp(title.str, "propagator")==0 &&\
str_cmp(title.str, "input_polynomial")==0 &&\
str_cmp(title.str, "id_table")==0 ){
char_array_cpy((*str_args).strs[i], &tmp_str);
str_array_append_noinit(tmp_str, &new_args);
}
free_Char_Array(title);
}
free_Fields_Table(fields);
free_Str_Array(*str_args);
*str_args=new_args;
return(0);
}
// generate the Kondo fields table
int kondo_fields_table(int box_count, Char_Array* str_fields, Fields_Table* fields){
int i,j;
init_Char_Array(str_fields,STR_SIZE);
char_array_snprintf(str_fields, "#!fields\n");
// external fields
char_array_append_str("x:",str_fields);
for(i=0;i<KONDO_SPIN;i++){
char_array_snprintf(str_fields, "%d,%d", 10*(i+10*KONDO_A_OFFSET), 10*(i+10*KONDO_B_OFFSET));
if(i<KONDO_SPIN-1){
char_array_append(',',str_fields);
}
}
char_array_append('\n',str_fields);
// internal fields: A
char_array_append_str("i:",str_fields);
for(i=0;i<KONDO_SPIN;i++){
for(j=1;j<=box_count;j++){
char_array_snprintf(str_fields, "%d", 10*(i+10*KONDO_A_OFFSET)+j);
char_array_append(',',str_fields);
}
}
// B
for(i=0;i<KONDO_SPIN;i++){
for(j=1;j<=2;j++){
char_array_snprintf(str_fields, "%d", 10*(i+10*KONDO_B_OFFSET)+j);
if(i<KONDO_SPIN-1 || j<2){
char_array_append(',',str_fields);
}
}
}
char_array_append('\n',str_fields);
// parameters
char_array_append_str("h:",str_fields);
// h
for(i=0;i<KONDO_DIM;i++){
char_array_snprintf(str_fields, "%d,", 10*(i+10*KONDO_H_OFFSET));
}
// t
for(i=0;i<KONDO_DIM;i++){
char_array_snprintf(str_fields, "%d", 10*(i+10*KONDO_T_OFFSET));
if(i<KONDO_DIM-1){
char_array_append(',', str_fields);
}
}
char_array_append('\n', str_fields);
// declare Fermions
char_array_append_str("f:",str_fields);
// external fields
for(i=0;i<KONDO_SPIN;i++){
char_array_snprintf(str_fields, "%d,%d", 10*(i+10*KONDO_A_OFFSET), 10*(i+10*KONDO_B_OFFSET));
char_array_append(',',str_fields);
}
// internal fields: A
for(i=0;i<KONDO_SPIN;i++){
for(j=1;j<=box_count;j++){
char_array_snprintf(str_fields, "%d", 10*(i+10*KONDO_A_OFFSET)+j);
char_array_append(',',str_fields);
}
}
// B
for(i=0;i<KONDO_SPIN;i++){
for(j=1;j<=2;j++){
char_array_snprintf(str_fields, "%d", 10*(i+10*KONDO_B_OFFSET)+j);
if(i<KONDO_SPIN-1 || j<2){
char_array_append(',',str_fields);
}
}
}
char_array_append('\n',str_fields);
// declare noncommuting
char_array_append_str("a:",str_fields);
for(i=0;i<KONDO_DIM;i++){
char_array_snprintf(str_fields, "%d", 10*(i+10*KONDO_T_OFFSET));
if(i<KONDO_DIM-1){
char_array_append(',',str_fields);
}
}
char_array_append('\n', str_fields);
// parse fields table
parse_input_fields(*str_fields, fields);
return(0);
}
// generate Kondo symbols
int kondo_symbols(Char_Array* str_symbols, int box_count, Fields_Table* fields){
int i,j,k,l;
Char_Array tmp_str;
Polynomial poly;
char letters[3]={'A','B','h'};
init_Char_Array(str_symbols, STR_SIZE);
char_array_snprintf(str_symbols, "#!symbols\n");
// loop over box index
for(i=1;i<=box_count;i++){
// loop over letters (A and B)
for(j=0;j<2;j++){
// loop over space dimension
for(k=0;k<KONDO_DIM;k++){
// write index
char_array_snprintf(str_symbols, "%d=", 100*(10*(KONDO_A_OFFSET+j)+k)+i);
// write the name of the scalar product
init_Char_Array(&tmp_str, 6);
char_array_snprintf(&tmp_str, "%c%d%d", letters[j], k, i);
// compute corresponding polynomial
kondo_resolve_ABht(tmp_str.str, &poly, *fields);
free_Char_Array(tmp_str);
// write to output
polynomial_sprint(poly, str_symbols);
free_Polynomial(poly);
// add ,
char_array_snprintf(str_symbols,",\n");
}
}
}
// scalar products
// loop over box index
for(i=1;i<=box_count;i++){
// loop over letters
for(j=0;j<3;j++){
for(k=0;k<3;k++){
// write index
char_array_snprintf(str_symbols, "%d=", 1000*(10*(KONDO_A_OFFSET+j)+KONDO_A_OFFSET+k)+i);
for(l=0;l<KONDO_DIM;l++){
char_array_snprintf(str_symbols, "(1)");
if(j<2){
char_array_snprintf(str_symbols,"[f%d]", 100*(10*(KONDO_A_OFFSET+j)+l)+i);
}
else{
char_array_snprintf(str_symbols,"[f%d]", 10*(10*(KONDO_A_OFFSET+j)+l));
}
if(k<2){
char_array_snprintf(str_symbols,"[f%d]", 100*(10*(KONDO_A_OFFSET+k)+l)+i);
}
else{
char_array_snprintf(str_symbols,"[f%d]", 10*(10*(KONDO_A_OFFSET+k)+l));
}
if(l<KONDO_DIM-1){
char_array_append('+',str_symbols);
}
}
// add ,
char_array_snprintf(str_symbols,",\n");
}
}
}
// vector products
for(i=1;i<=box_count;i++){
char_array_snprintf(str_symbols, "%d=", 100*(100*(KONDO_A_OFFSET)+10*KONDO_B_OFFSET+KONDO_H_OFFSET)+i);
for(l=0;l<KONDO_DIM;l++){
// remember (-1 %3 = -1)
char_array_snprintf(str_symbols, "(1)[f%d][f%d][f%d]+(-1)[f%d][f%d][f%d]", 100*(10*KONDO_A_OFFSET+((l+1)%KONDO_DIM))+i, 100*(10*KONDO_B_OFFSET+((l+2)%KONDO_DIM))+i, 10*(10*KONDO_H_OFFSET+l), 100*(10*KONDO_A_OFFSET+((l+2)%KONDO_DIM))+i, 100*(10*KONDO_B_OFFSET+((l+1)%KONDO_DIM))+i, 10*(10*KONDO_H_OFFSET+l));
if(l<KONDO_DIM-1){
char_array_append('+',str_symbols);
}
}
// add ,
if(i<box_count){
char_array_snprintf(str_symbols,",\n");
}
}
return(0);
}
// generate Kondo groups (groups of independent variables)
int kondo_groups(Char_Array* str_groups, int box_count){
int i,j;
init_Char_Array(str_groups, STR_SIZE);
char_array_snprintf(str_groups, "#!groups\n");
char_array_append('(',str_groups);
for(i=0;i<KONDO_DIM;i++){
for(j=1;j<=box_count;j++){
char_array_snprintf(str_groups, "%d",100*(10*KONDO_A_OFFSET+i)+j);
if(j<box_count || i<KONDO_DIM-1){
char_array_append(',',str_groups);
}
}
}
char_array_append(')',str_groups);
char_array_append('\n',str_groups);
char_array_append('(',str_groups);
for(i=0;i<KONDO_DIM;i++){
for(j=1;j<=box_count;j++){
char_array_snprintf(str_groups, "%d",100*(10*KONDO_B_OFFSET+i)+j);
if(j<box_count || i<KONDO_DIM-1){
char_array_append(',',str_groups);
}
}
}
char_array_append(')',str_groups);
char_array_append('\n',str_groups);
return(0);
}
// generate Kondo identities
// h_3^2=1-h_1^2-h_2^2
// and Pauli matrices
int kondo_identities(Char_Array* str_identities){
int i;
init_Char_Array(str_identities,STR_SIZE);
char_array_snprintf(str_identities, "#!identities\n");
// Pauli matrices
for(i=0;i<KONDO_DIM;i++){
char_array_snprintf(str_identities,"[f%d][f%d]=(1),\n",10*(10*KONDO_T_OFFSET+i),10*(10*KONDO_T_OFFSET+i));
char_array_snprintf(str_identities,"[f%d][f%d]=(s{-1})[f%d],\n",10*(10*KONDO_T_OFFSET+i),10*(10*KONDO_T_OFFSET+(i+1)%3),10*(10*KONDO_T_OFFSET+(i+2)%3));
char_array_snprintf(str_identities,"[f%d][f%d]=((-1)s{-1})[f%d],\n",10*(10*KONDO_T_OFFSET+(i+2)%3),10*(10*KONDO_T_OFFSET+(i+1)%3),10*(10*KONDO_T_OFFSET+i));
}
// h
char_array_snprintf(str_identities, "[f%d][f%d]=(1)",10*(KONDO_DIM-1+10*KONDO_H_OFFSET),10*(KONDO_DIM-1+10*KONDO_H_OFFSET));
for(i=0;i<KONDO_DIM-1;i++){
char_array_snprintf(str_identities, "+(-1)[f%d][f%d]",10*(i+10*KONDO_H_OFFSET),10*(i+10*KONDO_H_OFFSET));
}
return(0);
}
// convert the Kondo propagator
int kondo_propagator(Char_Array str_kondo_propagator, Char_Array* str_propagator){
int i,j;
// buffer
char* buffer=calloc(str_kondo_propagator.length+1,sizeof(char));
char* buffer_ptr=buffer;
// offset and index for each element
int offset[2]={-1,-1};
int index[2]={-1,-1};
int mode;
int comment=0;
// allocate memory
init_Char_Array(str_propagator,STR_SIZE);
// reproduce the loop from parse_input_propagatore but merely copy values, and replace indices
mode=PP_INDEX_MODE;
for(j=0;j<str_kondo_propagator.length;j++){
if(comment==1){
// write comments to str
char_array_append(str_kondo_propagator.str[j],str_propagator);
if(str_kondo_propagator.str[j]=='\n'){
comment=0;
}
}
else{
switch(str_kondo_propagator.str[j]){
// indices
case ';':
if(mode==PP_INDEX_MODE){
get_offset_index(buffer,offset,index);
buffer_ptr=buffer;
*buffer_ptr='\0';
}
break;
case ':':
if(mode==PP_INDEX_MODE){
get_offset_index(buffer,offset+1,index+1);
buffer_ptr=buffer;
*buffer_ptr='\0';
mode=PP_NUMBER_MODE;
}
break;
// num
case ',':
if(mode==PP_NUMBER_MODE && offset[0]>=0 && offset[1]>=0 && index[0]>=0 && index[1]>=0){
// write indices and num
for(i=0;i<KONDO_SPIN;i++){
char_array_snprintf(str_propagator,"%d;%d:%s,",10*(i+10*offset[0])+index[0], 10*(i+10*offset[1])+index[1], buffer);
}
buffer_ptr=buffer;
*buffer_ptr='\0';
mode=PP_INDEX_MODE;
}
break;
// comment
case '#':
comment=1;
char_array_append(str_kondo_propagator.str[j],str_propagator);
break;
// ignore line breaks
case '\n': break;
default:
buffer_ptr=str_addchar(buffer_ptr,str_kondo_propagator.str[j]);
break;
}
}
}
// last step
if(mode==PP_NUMBER_MODE){
for(i=0;i<KONDO_SPIN;i++){
char_array_snprintf(str_propagator,"%d;%d:%s",10*(i+10*offset[0])+index[0], 10*(i+10*offset[1])+index[1], buffer);
if(i<KONDO_SPIN-1){
char_array_append(',',str_propagator);
}
}
}
free(buffer);
return(0);
}
// convert Kondo input polynomial
int kondo_input_polynomial(Char_Array str_kondo_polynomial, Char_Array* str_polynomial, Fields_Table fields, int box_count){
Polynomial tmp_poly;
Polynomial out_poly;
Char_Array tmp_str_kondo_polynomial;
int i;
// whether there is a '%' in the input polynomial
int star=0;
init_Char_Array(str_polynomial, STR_SIZE);
char_array_snprintf(str_polynomial, "#!input_polynomial\n");
// check for a '%'
for(i=0;i<str_kondo_polynomial.length;i++){
if(str_kondo_polynomial.str[i]=='%'){
star=1;
break;
}
}
// if there is a '%', then take a product over boxes
if(star==1){
// product over i from 1 to box_count
for(i=1;i<=box_count;i++){
// replace '%' with the appropriate index
replace_star('0'+i,str_kondo_polynomial, &tmp_str_kondo_polynomial);
// read polynomial
parse_kondo_polynomial_factors(tmp_str_kondo_polynomial, &tmp_poly, fields);
// product
if(i==1){
polynomial_cpy(tmp_poly,&out_poly);
}
else{
polynomial_prod_chain(tmp_poly,&out_poly, fields);
}
free_Polynomial(tmp_poly);
free_Char_Array(tmp_str_kondo_polynomial);
}
}
// if no '%' then read polynomial as is
else{
parse_kondo_polynomial_factors(str_kondo_polynomial, &out_poly, fields);
}
// useful simplification
remove_unmatched_plusminus(&out_poly, fields);
polynomial_sprint(out_poly, str_polynomial);
free_Polynomial(out_poly);
return(0);
}
// convert the Kondo idtable
int kondo_idtable(Char_Array str_kondo_idtable, Char_Array* str_idtable, Fields_Table fields){
int j;
// buffer
char* buffer=calloc(str_kondo_idtable.length+1,sizeof(char));
char* buffer_ptr=buffer;
Polynomial tmp_poly;
int mode;
// allocate memory
init_Char_Array(str_idtable,STR_SIZE);
// reproduce the loop from parse_input_id_table but merely copy labels and indices, and replace Kondo polynomials
mode=PP_INDEX_MODE;
for(j=0;j<str_kondo_idtable.length;j++){
// unless inside a polynomial write to output
if(mode!=PP_POLYNOMIAL_MODE){
char_array_append(str_kondo_idtable.str[j],str_idtable);
}
switch(str_kondo_idtable.str[j]){
// end polynomial mode
case ',':
if(mode==PP_POLYNOMIAL_MODE){
mode=PP_INDEX_MODE;
// write polynomial
parse_kondo_polynomial_str(buffer, &tmp_poly, fields);
polynomial_sprint(tmp_poly, str_idtable);
free_Polynomial(tmp_poly);
char_array_append(',',str_idtable);
}
break;
case ':':
if(mode==PP_INDEX_MODE){
mode=PP_POLYNOMIAL_MODE;
buffer_ptr=buffer;
*buffer_ptr='\0';
}
break;
default:
if(mode==PP_POLYNOMIAL_MODE){
buffer_ptr=str_addchar(buffer_ptr,str_kondo_idtable.str[j]);
}
break;
}
}
//last step
if(mode==PP_POLYNOMIAL_MODE){
parse_kondo_polynomial_str(buffer, &tmp_poly, fields);
polynomial_sprint(tmp_poly, str_idtable);
free_Polynomial(tmp_poly);
}
free(buffer);
return(0);
}
// read a product of polynomials
int parse_kondo_polynomial_factors(Char_Array str_polynomial, Polynomial* output, Fields_Table fields){
int j;
// buffer
char* buffer=calloc(str_polynomial.length+1,sizeof(char));
char* buffer_ptr=buffer;
Polynomial tmp_poly;
// allocate memory
init_Polynomial(output,POLY_SIZE);
for(j=0;j<str_polynomial.length;j++){
switch(str_polynomial.str[j]){
case '*':
parse_kondo_polynomial_str(buffer, &tmp_poly, fields);
if((*output).length==0){
polynomial_concat(tmp_poly, output);
}
else{
polynomial_prod_chain(tmp_poly, output, fields);
}
free_Polynomial(tmp_poly);
buffer_ptr=buffer;
*buffer_ptr='\0';
break;
default:
buffer_ptr=str_addchar(buffer_ptr,str_polynomial.str[j]);
break;
}
}
//last step
parse_kondo_polynomial_str(buffer, &tmp_poly, fields);
if((*output).length==0){
polynomial_concat(tmp_poly, output);
}
else{
polynomial_prod_chain(tmp_poly, output, fields);
}
free_Polynomial(tmp_poly);
free(buffer);
return(0);
}
// read a kondo polynomial and convert it to a polynomial expressed in terms of the fields in the fields table
int parse_kondo_polynomial_str(char* str_polynomial, Polynomial* output, Fields_Table fields){
// input pointer
char* polynomial_ptr;
// buffer
char* buffer=calloc(str_len(str_polynomial),sizeof(char));
char* buffer_ptr=buffer;
int mode;
int comment=0;
int parenthesis_count=0;
int i;
int offset1, offset2;
int index;
Polynomial tmp_poly;
Number tmp_num, tmp1_num;
Int_Array tmp_factor, tmp_monomial, dummy_factor;
Polynomial scalar_prod_poly;
// allocate memory
init_Polynomial(output,POLY_SIZE);
init_Polynomial(&tmp_poly,MONOMIAL_SIZE);
tmp_num=number_one();
init_Int_Array(&tmp_factor, MONOMIAL_SIZE);
*buffer_ptr='\0';
// loop over the input polynomial
// start in null mode
mode=PP_NULL_MODE;
for(polynomial_ptr=str_polynomial;*polynomial_ptr!='\0';polynomial_ptr++){
if(comment==1){
if(*polynomial_ptr=='\n'){
comment=0;
}
}
else{
switch(*polynomial_ptr){
// new monomial
case '+':
if(mode==PP_NULL_MODE){
// if not a constant
if(tmp_poly.length>0){
// write num
polynomial_multiply_scalar(tmp_poly, tmp_num);
// replace factor
for(i=0;i<tmp_poly.length;i++){
free_Int_Array(tmp_poly.factors[i]);
int_array_cpy(tmp_factor,tmp_poly.factors+i);
}
}
// if constant
else{
init_Int_Array(&tmp_monomial,1);
polynomial_append(tmp_monomial,tmp_factor,tmp_num,&tmp_poly);
free_Int_Array(tmp_monomial);
}
free_Int_Array(tmp_factor);
free_Number(tmp_num);
// write polynomial
polynomial_concat_noinit(tmp_poly, output);
// reset tmp_poly
init_Polynomial(&tmp_poly,MONOMIAL_SIZE);
tmp_num=number_one();
init_Int_Array(&tmp_factor,MONOMIAL_SIZE);
}
break;
// numerical pre-factor
case '(':
if(mode==PP_NULL_MODE){
mode=PP_NUMBER_MODE;
parenthesis_count=0;
buffer_ptr=buffer;
*buffer_ptr='\0';
}
else if(mode==PP_NUMBER_MODE){
// match parentheses
parenthesis_count++;
}
break;
case ')':
if(mode==PP_NUMBER_MODE){
if(parenthesis_count==0){
// write num
str_to_Number(buffer,&tmp1_num);
number_prod_chain(tmp1_num,&tmp_num);
free_Number(tmp1_num);
// back to null mode
mode=PP_NULL_MODE;
}
else{
parenthesis_count--;
}
}
break;
// enter factor mode
case '[':
if(mode==PP_NULL_MODE){
mode=PP_BRACKET_MODE;
}
break;
// factor mode
case 'l':
if(mode==PP_BRACKET_MODE){
mode=PP_FACTOR_MODE;
buffer_ptr=buffer;
*buffer_ptr='\0';
}
break;
// symbol mode
case 'f':
if(mode==PP_BRACKET_MODE){
mode=PP_FIELD_MODE;
buffer_ptr=buffer;
*buffer_ptr='\0';
}
break;
// read factor
case ']':
// factor
if(mode==PP_FACTOR_MODE){
sscanf(buffer,"%d",&i);
int_array_append(i,&tmp_factor);
}
// symbol
else if(mode==PP_FIELD_MODE){
// if polynomial exists, add to each monomial
if(tmp_poly.length>0){
for(i=0;i<tmp_poly.length;i++){
int_array_append(get_symbol_index(buffer), tmp_poly.monomials+i);
}
}
// if not, create a new term in the polynomial
else{
init_Int_Array(&tmp_monomial, MONOMIAL_SIZE);
int_array_append(get_symbol_index(buffer), &tmp_monomial);
init_Int_Array(&dummy_factor, 1);
polynomial_append_noinit(tmp_monomial, dummy_factor, number_one(), &tmp_poly);
}
}
// scalar product of symbols
else if(mode==PP_FIELD_SCALAR_MODE || mode==PP_FIELD_VECTOR_PROD_MODE){
get_offsets_index(buffer, &offset1, &offset2, &index);
// if polynomial exists, add to each monomial
if(tmp_poly.length>0){
for(i=0;i<tmp_poly.length;i++){
if(mode==PP_FIELD_SCALAR_MODE){
int_array_append(1000*(10*offset1+offset2)+index, tmp_poly.monomials+i);
}
else{
// vector product
int_array_append(100*(100*KONDO_A_OFFSET+10*KONDO_B_OFFSET+KONDO_H_OFFSET)+index, tmp_poly.monomials+i);
}
}
}
// if not, create a new term in the polynomial
else{
init_Int_Array(&tmp_monomial, MONOMIAL_SIZE);
if(mode==PP_FIELD_SCALAR_MODE){
int_array_append(1000*(10*offset1+offset2)+index, &tmp_monomial);
}
else{
// vector product
int_array_append(100*(100*KONDO_A_OFFSET+10*KONDO_B_OFFSET+KONDO_H_OFFSET)+index, &tmp_monomial);
}
init_Int_Array(&dummy_factor, 1);
polynomial_append_noinit(tmp_monomial, dummy_factor, number_one(), &tmp_poly);
}
}
// switch back to null mode
mode=PP_NULL_MODE;
break;
// symbol scalar product
case '.':
if(mode==PP_FIELD_MODE){
mode=PP_FIELD_SCALAR_MODE;
}
buffer_ptr=str_addchar(buffer_ptr,*polynomial_ptr);
break;
case 'x':
if(mode==PP_FIELD_MODE){
mode=PP_FIELD_VECTOR_PROD_MODE;
}
buffer_ptr=str_addchar(buffer_ptr,*polynomial_ptr);
break;
// scalar product
case '<':
if(mode==PP_NULL_MODE){
mode=PP_MONOMIAL_MODE;
buffer_ptr=buffer;
*buffer_ptr='\0';
}
break;
case '>':
if(mode==PP_MONOMIAL_MODE){
// resolve scalar product
kondo_resolve_scalar_prod(buffer, &scalar_prod_poly, fields);
// add to tmp_poly
if(tmp_poly.length==0){
polynomial_concat(scalar_prod_poly,&tmp_poly);
}
else{
polynomial_prod_chain(scalar_prod_poly,&tmp_poly,fields);
}
free_Polynomial(scalar_prod_poly);
mode=PP_NULL_MODE;
}
break;
// characters to ignore
case ' ':break;
case '&':break;
case '\n':break;
// comments
case '#':
comment=1;
break;
default:
if(mode!=PP_NULL_MODE){
// write to buffer
buffer_ptr=str_addchar(buffer_ptr,*polynomial_ptr);
}
break;
}
}
}
// last term
if(tmp_poly.length>0){
polynomial_multiply_scalar(tmp_poly,tmp_num);
for(i=0;i<tmp_poly.length;i++){
free_Int_Array(tmp_poly.factors[i]);
int_array_cpy(tmp_factor,tmp_poly.factors+i);
}
}
else{
init_Int_Array(&tmp_monomial,1);
polynomial_append(tmp_monomial,tmp_factor,tmp_num,&tmp_poly);
}
free_Int_Array(tmp_factor);
free_Number(tmp_num);
polynomial_concat_noinit(tmp_poly, output);
// simplify
polynomial_simplify(output, fields);
free(buffer);
return(0);
}
// as Char_Array
int parse_kondo_polynomial(Char_Array kondo_polynomial_str, Polynomial* polynomial, Fields_Table fields){
char* str;
char_array_to_str(kondo_polynomial_str, &str);
parse_kondo_polynomial_str(str, polynomial, fields);
free(str);
return(0);
}
// read Aij, Bij, hi, ti where i is a space dimension and j is a box index
int kondo_resolve_ABht(char* str, Polynomial* output, Fields_Table fields){
char* ptr;
// offset (A,B, H or T)
int offset=-1;
// dimension
int dim=-1;
// box index
int index=-1;
// polynomial for each term
Polynomial psi[KONDO_SPIN];
Polynomial poly_conjugate;
Int_Array monomial;
Int_Array factor;
Number_Matrix pauli_mat;
int i,a,b;
// memory
init_Polynomial(output, MONOMIAL_SIZE);
for(ptr=str;*ptr!='\0';ptr++){
switch(*ptr){
case 'A':
offset=KONDO_A_OFFSET;
break;
case 'a':
offset=KONDO_A_OFFSET;
break;
case 'B':
offset=KONDO_B_OFFSET;
break;
case 'b':
offset=KONDO_B_OFFSET;
break;
case 'h':
offset=KONDO_H_OFFSET;
break;
case 't':
offset=KONDO_T_OFFSET;
break;
default:
// set index if dim was already set
if(dim>=0){
index=*ptr-'0';
}
else{
dim=*ptr-'0';
}
}
}
// turn B3 into B2 and B4 into B1
if(offset==KONDO_B_OFFSET){
switch(index){
case 3:
index=2;
break;
case 4:
index=1;
break;
}
}
// h's and t's
if(offset==KONDO_H_OFFSET || offset==KONDO_T_OFFSET){
// external field
init_Int_Array(&monomial,1);
init_Int_Array(&factor,1);
int_array_append(10*(dim+10*offset), &monomial);
polynomial_append_noinit(monomial, factor, number_one(), output);
}
// psi's
else{
// construct spin indices
for(i=0;i<KONDO_SPIN;i++){
init_Polynomial(psi+i,2);
// external field
init_Int_Array(&monomial,1);
init_Int_Array(&factor,1);
int_array_append(10*(i+10*offset), &monomial);
polynomial_append_noinit(monomial, factor, number_one(), psi+i);
// internal field if applicable
if(index>0){
init_Int_Array(&monomial,1);
init_Int_Array(&factor,1);
int_array_append(10*(i+10*offset)+index, &monomial);
polynomial_append_noinit(monomial, factor, number_one(), psi+i);
}
}
// multiply by Pauli matrices
Pauli_matrix(dim+1,&pauli_mat);
for(a=0;a<KONDO_SPIN;a++){
for(b=0;b<KONDO_SPIN;b++){
polynomial_cpy(psi[b],&poly_conjugate);
polynomial_conjugate(poly_conjugate);
polynomial_multiply_scalar(poly_conjugate, pauli_mat.matrix[a][b]);
polynomial_prod_chain(psi[a],&poly_conjugate,fields);
// correct sign: psi[a]^+ should be on the left of psi[b]^-
polynomial_multiply_Qscalar(poly_conjugate,quot(-1,1));
// add to poly
polynomial_concat_noinit(poly_conjugate, output);
}
}
free_Number_Matrix(pauli_mat);
// free spin indices
for(i=0;i<KONDO_SPIN;i++){
free_Polynomial(psi[i]);
}
}
return(0);
}
#define K_VECT_PROD 1
#define K_SCALAR_PROD 2
// read a Kondo scalar product (generalized to vector products as well)
int kondo_resolve_scalar_prod(char* str, Polynomial* output, Fields_Table fields){
char* ptr;
// offset of each term (A,B,H or T)
int offset=-1;
// index of each term (0,...,box_count)
int index=0;
int i;
int operation=0;
Polynomial poly_vect1[KONDO_DIM];
Polynomial poly_vect2[KONDO_DIM];
// memory
init_Polynomial(output, MONOMIAL_SIZE);
for(ptr=str;*ptr!='\0';ptr++){
switch(*ptr){
case 'A':
offset=KONDO_A_OFFSET;
break;
case 'a':
offset=KONDO_A_OFFSET;
break;
case 'B':
offset=KONDO_B_OFFSET;
break;
case 'b':
offset=KONDO_B_OFFSET;
break;
case 'h':
offset=KONDO_H_OFFSET;
break;
case 't':
offset=KONDO_T_OFFSET;
break;
// scalar product
case '.':
// if no previous vector product
if(operation!=K_VECT_PROD){
kondo_polynomial_vector(offset, index, &poly_vect1, fields);
}
// compute vector product
else{
kondo_polynomial_vector(offset, index, &poly_vect2, fields);
kondo_polynomial_vector_product(&poly_vect1, poly_vect2, fields);
}
operation=K_SCALAR_PROD;
break;
// vector product
case 'x':
if(offset>=0){
kondo_polynomial_vector(offset, index, &poly_vect1, fields);
operation=K_VECT_PROD;
}
break;
// index
default:
// char to int
index=*ptr-'0';
}
}
// final scalar product
if(operation==K_SCALAR_PROD){
if(offset>=0){
kondo_polynomial_vector(offset, index, &poly_vect2, fields);
kondo_polynomial_scalar_product(poly_vect1, poly_vect2, output, fields);
}
}
// free memory
for(i=0;i<KONDO_DIM;i++){
free_Polynomial(poly_vect1[i]);
free_Polynomial(poly_vect2[i]);
}
return(0);
}
// compute a scalar product of polynomial vectors
int kondo_polynomial_scalar_product(Polynomial poly_vect1[3], Polynomial poly_vect2[3], Polynomial* output, Fields_Table fields){
int i;
Polynomial tmp_poly;
for(i=0;i<KONDO_DIM;i++){
polynomial_prod(poly_vect1[i],poly_vect2[i],&tmp_poly,fields);
// add to output
polynomial_concat_noinit(tmp_poly, output);
}
polynomial_simplify(output, fields);
return(0);
}
// compute a vector product of polynomial vectors
int kondo_polynomial_vector_product(Polynomial (*poly_vect1)[3], Polynomial poly_vect2[3], Fields_Table fields){
int i;
Polynomial out[3];
Polynomial tmp_poly;
for(i=0;i<3;i++){
init_Polynomial(out+i, POLY_SIZE);
polynomial_prod((*poly_vect1)[(i+1)%3],poly_vect2[(i+2)%3], &tmp_poly, fields);
polynomial_concat_noinit(tmp_poly, out+i);
polynomial_prod((*poly_vect1)[(i+2)%3],poly_vect2[(i+1)%3], &tmp_poly, fields);
polynomial_multiply_Qscalar(tmp_poly,quot(-1,1));
polynomial_concat_noinit(tmp_poly, out+i);
}
for(i=0;i<3;i++){
free_Polynomial((*poly_vect1)[i]);
(*poly_vect1)[i]=out[i];
}
return(0);
}
// compute the 3 components of a kondo vector
int kondo_polynomial_vector(int offset, int index, Polynomial (*polys)[3], Fields_Table fields){
int i,a,b;
// polynomial for each term
Polynomial psi[KONDO_SPIN];
Polynomial poly_conjugate;
Int_Array monomial;
Int_Array factor;
Number_Matrix pauli_mat;
for(i=0;i<KONDO_DIM;i++){
// memory
init_Polynomial((*polys)+i,POLY_SIZE);
}
// h's and t's
if(offset==KONDO_H_OFFSET || offset==KONDO_T_OFFSET){
// construct every component field
for(i=0;i<KONDO_DIM;i++){
// external field
init_Int_Array(&monomial,1);
init_Int_Array(&factor,1);
int_array_append(10*(i+10*offset), &monomial);
polynomial_append_noinit(monomial, factor, number_one(), (*polys)+i);
}
}
// psi's
else{
// construct spin indices
for(i=0;i<KONDO_SPIN;i++){
init_Polynomial(psi+i,2);
// external field
init_Int_Array(&monomial,1);
init_Int_Array(&factor,1);
int_array_append(10*(i+10*offset), &monomial);
polynomial_append_noinit(monomial, factor, number_one(), psi+i);
// internal field if applicable
if(index>0){
init_Int_Array(&monomial,1);
init_Int_Array(&factor,1);
int_array_append(10*(i+10*offset)+index, &monomial);
polynomial_append_noinit(monomial, factor, number_one(), psi+i);
}
}
// multiply by Pauli matrices
for(i=0;i<KONDO_DIM;i++){
Pauli_matrix(i+1,&pauli_mat);
for(a=0;a<KONDO_SPIN;a++){
for(b=0;b<KONDO_SPIN;b++){
polynomial_cpy(psi[b],&poly_conjugate);
polynomial_conjugate(poly_conjugate);
polynomial_multiply_scalar(poly_conjugate, pauli_mat.matrix[a][b]);
polynomial_prod_chain(psi[a],&poly_conjugate,fields);
// correct sign: psi[a]^+ should be on the left of psi[b]^-
polynomial_multiply_Qscalar(poly_conjugate,quot(-1,1));
// add to polys[j]
polynomial_concat_noinit(poly_conjugate, (*polys)+i);
}
}
free_Number_Matrix(pauli_mat);
}
// free spin indices
for(i=0;i<KONDO_SPIN;i++){
free_Polynomial(psi[i]);
}
}
return(0);
}
// read a scalar product of symbols
int kondo_resolve_scalar_prod_symbols(char* str, Polynomial* output){
char* ptr;
// first or second term
int term=0;
// offset of each term (A,B,H or T)
int offset[2];
// index of each term (0,...,box_count)
int index[2]={0,0};
Int_Array monomial;
Int_Array factor;
int i;
// memory
init_Polynomial(output, KONDO_DIM);
for(ptr=str;*ptr!='\0';ptr++){
switch(*ptr){
case 'A':
offset[term]=KONDO_A_OFFSET;
break;
case 'a':
offset[term]=KONDO_A_OFFSET;
break;
case 'B':
offset[term]=KONDO_B_OFFSET;
break;
case 'b':
offset[term]=KONDO_B_OFFSET;
break;
case 'h':
offset[term]=KONDO_H_OFFSET;
break;
case 't':
offset[term]=KONDO_T_OFFSET;
break;
// switch term
case '.':
term=1-term;
break;
default:
// char to int
index[term]=*ptr-'0';
}
}
// scalar product
for(i=0;i<KONDO_DIM;i++){
init_Int_Array(&monomial,2);
init_Int_Array(&factor, 1);
if(offset[0]==KONDO_H_OFFSET || offset[0]==KONDO_T_OFFSET){
int_array_append(10*(10*offset[0]+i)+index[0], &monomial);
}
else{
int_array_append(100*(10*offset[0]+i)+index[0], &monomial);
}
if(offset[1]==KONDO_H_OFFSET || offset[1]==KONDO_T_OFFSET){
int_array_append(10*(10*offset[1]+i)+index[1], &monomial);
}
else{
int_array_append(100*(10*offset[1]+i)+index[1], &monomial);
}
polynomial_append_noinit(monomial, factor, number_one(), output);
}
return(0);
}
// get the offset and index of a monomial term
// (e.g. A1 yields KONDO_A_OFFSET and 1)
int get_offset_index(char* str, int* offset, int* index){
char* ptr;
for(ptr=str;*ptr!='\0';ptr++){
switch(*ptr){
case 'A':
*offset=KONDO_A_OFFSET;
break;
case 'a':
*offset=KONDO_A_OFFSET;
break;
case 'B':
*offset=KONDO_B_OFFSET;
break;
case 'b':
*offset=KONDO_B_OFFSET;
break;
case 'h':
*offset=KONDO_H_OFFSET;
break;
case 't':
*offset=KONDO_T_OFFSET;
break;
default:
// char to int
*index=*ptr-'0';
}
}
return(0);
}
// get the offsets and index of a scalar product
int get_offsets_index(char* str, int* offset1, int* offset2, int* index){
int offset[2]={-1,-1};
char* ptr;
int term=0;
*index=-1;
for(ptr=str;*ptr!='\0';ptr++){
switch(*ptr){
case 'A':
offset[term]=KONDO_A_OFFSET;
break;
case 'a':
offset[term]=KONDO_A_OFFSET;
break;
case 'B':
offset[term]=KONDO_B_OFFSET;
break;
case 'b':
offset[term]=KONDO_B_OFFSET;
break;
case 'h':
offset[term]=KONDO_H_OFFSET;
break;
case 't':
offset[term]=KONDO_T_OFFSET;
break;
// switch term
case '.':
term=1-term;
break;
default:
// char to int
*index=*ptr-'0';
}
}
*offset1=offset[0];
*offset2=offset[1];
// if no A's or B's, then index=0
if((offset[0]==KONDO_H_OFFSET || offset[0]==KONDO_T_OFFSET) && (offset[1]==KONDO_H_OFFSET || offset[1]==KONDO_T_OFFSET)){
*index=0;
}
return(0);
}
// get the index of the symbol corresponding to a given string
int get_symbol_index(char* str){
char* ptr;
int offset=-1;
int index=0;
int dim=-1;
// first check whether the field already is an index
for(ptr=str;*ptr!='\0';ptr++){
if((*ptr-'0'>=10 || *ptr-'0'<0) && (*ptr!='-')){
break;
}
}
if(*ptr=='\0'){
sscanf(str,"%d",&index);
return(index);
}
for(ptr=str;*ptr!='\0';ptr++){
switch(*ptr){
case 'A':
offset=KONDO_A_OFFSET;
break;
case 'a':
offset=KONDO_A_OFFSET;
break;
case 'B':
offset=KONDO_B_OFFSET;
break;
case 'b':
offset=KONDO_B_OFFSET;
break;
case 'h':
offset=KONDO_H_OFFSET;
break;
case 't':
offset=KONDO_T_OFFSET;
break;
default:
// set index if dim was already set
if(dim>=0){
index=*ptr-'0';
}
else{
dim=*ptr-'0';
}
}
}
if(offset==-1){
return(-1);
}
// no symbol for h or t
if(offset==KONDO_H_OFFSET || offset==KONDO_T_OFFSET){
return(10*(10*offset+dim));
}
else{
return(100*(10*offset+dim)+index);
}
}
Reference in New Issue View Git Blame Copy Permalink