OSDN > Finden Software > Multimedia > Graphics > fermisurfer > SCM > git > fermisurfer > Commit

fermisurfer
Fork
fermisurfer
android

R/O
HTTP
SSH
HTTPS

fermisurfer: Commit

fermisurfer Git

Commit MetaInfo

Revision	fe4d3999aa301f62aac81d0936a507e52361b235 (tree)
Zeit	2017-05-10 00:52:26
Autor	mitsuaki1987 <kawamitsuaki@gmai...>
Commiter	mitsuaki1987

Log Message

Add function for the 2D Fermi surface. It still has bugs.

Ändern Zusammenfassung

modified: doc/fermisurfer.doxygen (diff)
modified: src/Makefile (diff)
modified: src/bz_lines.c (diff)
modified: src/calc_nodeline.c (diff)
modified: src/draw.c (diff)
modified: src/fermisurfer.c (diff)
modified: src/free_patch.c (diff)
modified: src/initialize.c (diff)
modified: src/menu.c (diff)
modified: src/read_file.c (diff)
modified: src/variable.h (diff)

Diff

--- a/doc/fermisurfer.doxygen

+++ b/doc/fermisurfer.doxygen

		@@ -91,7 +91,7 @@ ALLOW_UNICODE_NAMES = NO
91	91	# Ukrainian and Vietnamese.
92	92	# The default value is: English.
93	93
94		-OUTPUT_LANGUAGE = Japanese
	94	+OUTPUT_LANGUAGE = English
95	95
96	96	# If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member
97	97	# descriptions after the members that are listed in the file and class

		@@ -1505,7 +1505,7 @@ USE_MATHJAX = YES
1505	1505	# The default value is: HTML-CSS.
1506	1506	# This tag requires that the tag USE_MATHJAX is set to YES.
1507	1507
1508		-MATHJAX_FORMAT = NativeMML
	1508	+MATHJAX_FORMAT = HTML-CSS
1509	1509
1510	1510	# When MathJax is enabled you need to specify the location relative to the HTML
1511	1511	# output directory using the MATHJAX_RELPATH option. The destination directory

		@@ -1518,7 +1518,7 @@ MATHJAX_FORMAT = NativeMML
1518	1518	# The default value is: http://cdn.mathjax.org/mathjax/latest.
1519	1519	# This tag requires that the tag USE_MATHJAX is set to YES.
1520	1520
1521		-MATHJAX_RELPATH = http://cdn.mathjax.org/mathjax/latest
	1521	+MATHJAX_RELPATH = https://cdn.mathjax.org/mathjax/latest
1522	1522
1523	1523	# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
1524	1524	# extension names that should be enabled during MathJax rendering. For example

		@@ -2050,7 +2050,7 @@ INCLUDE_FILE_PATTERNS =
2050	2050	# recursively expanded use the := operator instead of the = operator.
2051	2051	# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
2052	2052
2053		-PREDEFINED =
	2053	+PREDEFINED = _OPENMP
2054	2054
2055	2055	# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
2056	2056	# tag can be used to specify a list of macro names that should be expanded. The

--- a/src/Makefile

+++ b/src/Makefile

		@@ -17,7 +17,8 @@ initialize.o \
17	17	kumo.o \
18	18	menu.o \
19	19	operation.o \
20		-read_file.o
	20	+read_file.o \
	21	+section.o
21	22
22	23	HEADERS= \
23	24	basic_math.h \

		@@ -31,6 +32,7 @@ kumo.h \
31	32	menu.h \
32	33	operation.h \
33	34	read_file.h \
	35	+section.h \
34	36	variable.h
35	37
36	38	all:fermisurfer bxsf2frmsf

		@@ -67,3 +69,4 @@ kumo.o:$(HEADERS)
67	69	menu.o:$(HEADERS)
68	70	operation.o:$(HEADERS)
69	71	read_file.o:$(HEADERS)
	72	+section.o:$(HEADERS)

--- a/src/bz_lines.c

+++ b/src/bz_lines.c

		@@ -37,7 +37,7 @@ THE SOFTWARE.
37	37	/**
38	38	Judge wheser this line is the edge of 1st BZ
39	39	*/
40		-int bragg_vert(
	40	+static int bragg_vert(
41	41	int ibr /*< [in] Index of a Bragg plane/,
42	42	int jbr /*< [in] Index of a Bragg plane/,
43	43	int nbr /*< [in] /,

		@@ -95,17 +95,16 @@ int bragg_vert(
95	95	this line is not a BZ boundary
96	96	*/
97	97	return 0;
98		- /**/
99	98	}/* bragg_vert */
100	99	/**
101	100	Compute Brillouin zone boundariy lines
102	101	*/
103	102	void bz_lines() {
104	103	/**/
105		- int ibr, jbr, nbr, ibzl, i, j, lvert;
	104	+ int ibr, jbr, nbr, i, j, lvert;
106	105	GLfloat vert[2][3];
107	106	/**/
108		- ibzl = 0;
	107	+ nbzl = 0;
109	108	/**/
110	109	for (ibr = 0; ibr < 26; ++ibr) {
111	110	for (jbr = 0; jbr < 26; ++jbr) {

		@@ -119,26 +118,8 @@ void bz_lines() {
119	118	lvert = bragg_vert(ibr, jbr, nbr, vert[1], vert[0]);
120	119	if (lvert == 0) continue;
121	120	/**/
122		- if (query == 1) {
123		- nbzl = nbzl + 1;
124		- }
125		- else {
126		- for (i = 0; i<2; ++i) for (j = 0; j<3; ++j) bzl[ibzl][i][j] = vert[i][j];
127		- ibzl = ibzl + 1;
128		- }
129		- /**/
130		- }
131		- }
132		- /**/
133		- if (query == 1) {
134		- printf(" # of lines for BZ : %d\n", nbzl);
135		- /**/
136		- bzl = (GLfloat**)malloc(nbzl sizeof(GLfloat*));
137		- for (ibzl = 0; ibzl < nbzl; ++ibzl) {
138		- bzl[ibzl] = (GLfloat*)malloc(2 sizeof(GLfloat*));
139		- for (i = 0; i < 2; ++i) {
140		- bzl[ibzl][i] = (GLfloat)malloc(3 sizeof(GLfloat));
141		- }/for (i = 0; i < 2; ++i)/
142		- }/for (ibzl = 0; ibzl < nbzl; ++ibzl)/
143		- }/if (query == 1)/
144		-} /* bz_lines */
	121	+ for (i = 0; i < 2; ++i) for (j = 0; j < 3; ++j) bzl[nbzl][i][j] = vert[i][j];
	122	+ nbzl = nbzl + 1;
	123	+ }/for (jbr = 0; jbr < 26; ++jbr)/
	124	+ }/for (ibr = 0; ibr < 26; ++ibr)/
	125	+}/bz_lines/

--- a/src/calc_nodeline.c

+++ b/src/calc_nodeline.c

		@@ -39,139 +39,118 @@ THE SOFTWARE.
39	39	void calc_nodeline() {
40	40	int ib, itri, i, j, nnl0, ithread;
41	41	GLfloat mprod[2];
42		- /*
43		- Query
44		- */
	42	+
45	43	#pragma omp parallel default(none) \
46		- shared(nb,nnl,matp,ntri,ntri_th) \
47		- private(ib,itri,mprod,nnl0,ithread)
	44	+ shared(nb,nnl,matp,kvnl,kvp,ntri,ntri_th,query) \
	45	+ private(ib,itri,mprod,i,nnl0,ithread)
48	46	{
49	47	ithread = get_thread();
50	48	for (ib = 0; ib < nb; ib++) {
51		- nnl0 = 0;
	49	+ if(query == 1) nnl0 = 0;
	50	+ else nnl0 = ntri_th[ib][ithread];
52	51	#pragma omp for
53	52	for (itri = 0; itri < ntri[ib]; ++itri) {
54	53	/**/
55	54	mprod[0] = matp[ib][itri][0] * matp[ib][itri][1];
56	55	mprod[1] = matp[ib][itri][1] * matp[ib][itri][2];
57	56	/**/
58		- if (fabsf(matp[ib][itri][0]) < 0.00001 && fabsf(matp[ib][itri][1]) < 0.00001) {
	57	+ if (fabsf(matp[ib][itri][0]) < 0.00001 && fabsf(matp[ib][itri][1]) < 0.00001) {
	58	+ if (query == 0) {
	59	+ for (i = 0; i < 3; ++i)kvnl[ib][nnl0][0][i] = kvp[ib][itri][0][i];
	60	+ for (i = 0; i < 3; ++i)kvnl[ib][nnl0][1][i] = kvp[ib][itri][1][i];
	61	+ }/if (query == 0)/
59	62	nnl0 += 1;
60		- }
61		- else if (fabsf(matp[ib][itri][0]) < 0.00001 && fabsf(matp[ib][itri][2]) < 0.00001) {
	63	+ }/if (fabsf(matp[ib][itri][0]) < 0.00001 && fabsf(matp[ib][itri][1]) < 0.00001)/
	64	+ else if (fabsf(matp[ib][itri][0]) < 0.00001 && fabsf(matp[ib][itri][2]) < 0.00001) {
	65	+ if (query == 0) {
	66	+ for (i = 0; i < 3; ++i)kvnl[ib][nnl0][0][i] = kvp[ib][itri][0][i];
	67	+ for (i = 0; i < 3; ++i)kvnl[ib][nnl0][1][i] = kvp[ib][itri][2][i];
	68	+ }/if (query == 0)/
62	69	nnl0 += 1;
63		- }
64		- else if (fabsf(matp[ib][itri][1]) < 0.00001 && fabsf(matp[ib][itri][2]) < 0.00001) {
	70	+ }/if (fabsf(matp[ib][itri][0]) < 0.00001 && fabsf(matp[ib][itri][2]) < 0.00001)/
	71	+ else if (fabsf(matp[ib][itri][1]) < 0.00001 && fabsf(matp[ib][itri][2]) < 0.00001) {
	72	+ if (query == 0) {
	73	+ for (i = 0; i < 3; ++i)kvnl[ib][nnl0][0][i] = kvp[ib][itri][1][i];
	74	+ for (i = 0; i < 3; ++i)kvnl[ib][nnl0][1][i] = kvp[ib][itri][2][i];
	75	+ }/if (query == 0)/
65	76	nnl0 += 1;
66		- }
	77	+ }/if (fabsf(matp[ib][itri][1]) < 0.00001 && fabsf(matp[ib][itri][2]) < 0.00001)/
67	78	else if (mprod[0] < 0.0) {
68	79	if (mprod[1] < 0.0) {
	80	+ if (query == 0) {
	81	+ for (i = 0; i < 3; ++i)kvnl[ib][nnl0][0][i] =
	82	+ (matp[ib][itri][0] * kvp[ib][itri][1][i] - matp[ib][itri][1] * kvp[ib][itri][0][i])
	83	+ / (matp[ib][itri][0] - matp[ib][itri][1]);
	84	+ for (i = 0; i < 3; ++i)kvnl[ib][nnl0][1][i] =
	85	+ (matp[ib][itri][1] * kvp[ib][itri][2][i] - matp[ib][itri][2] * kvp[ib][itri][1][i])
	86	+ / (matp[ib][itri][1] - matp[ib][itri][2]);
	87	+ }/if (query == 0)/
69	88	nnl0 += 1;
70		- }
	89	+ }/if (mprod[1] < 0.0)/
71	90	else {
	91	+ if (query == 0) {
	92	+ for (i = 0; i < 3; ++i)kvnl[ib][nnl0][0][i] =
	93	+ (matp[ib][itri][0] * kvp[ib][itri][1][i] - matp[ib][itri][1] * kvp[ib][itri][0][i])
	94	+ / (matp[ib][itri][0] - matp[ib][itri][1]);
	95	+ for (i = 0; i < 3; ++i)kvnl[ib][nnl0][1][i] =
	96	+ (matp[ib][itri][0] * kvp[ib][itri][2][i] - matp[ib][itri][2] * kvp[ib][itri][0][i])
	97	+ / (matp[ib][itri][0] - matp[ib][itri][2]);
	98	+ }/if (query == 0)/
72	99	nnl0 += 1;
73	100	}
74		- }
	101	+ }/* else if (mprod[0] < 0.0)*/
75	102	else if (mprod[1] < 0.0) {
	103	+ if (query == 0) {
	104	+ for (i = 0; i < 3; ++i)kvnl[ib][nnl0][0][i] =
	105	+ (matp[ib][itri][0] * kvp[ib][itri][2][i] - matp[ib][itri][2] * kvp[ib][itri][0][i])
	106	+ / (matp[ib][itri][0] - matp[ib][itri][2]);
	107	+ for (i = 0; i < 3; ++i)kvnl[ib][nnl0][1][i] =
	108	+ (matp[ib][itri][1] * kvp[ib][itri][2][i] - matp[ib][itri][2] * kvp[ib][itri][1][i])
	109	+ / (matp[ib][itri][1] - matp[ib][itri][2]);
	110	+ }/if (query == 0)/
76	111	nnl0 += 1;
77		- }
	112	+ }/else if (mprod[1] < 0.0)/
78	113	}/for (itri = 0; itri < ntri[ib]; ++itri)/
79		- ntri_th[ib][ithread] = nnl0;
	114	+ if (query == 1) ntri_th[ib][ithread] = nnl0;
80	115	}/for (ib = 0; ib < nb; ib++)/
81	116	}/* End of parallel region */
82	117	/*
83		- Sum node-lines in all threads
84		- */
85		- for (ib = 0; ib < nb; ib++) {
86		- for (ithread = 1; ithread < nthreads; ithread++) {
87		- ntri_th[ib][ithread] += ntri_th[ib][ithread - 1];
88		- }
89		- nnl[ib] = ntri_th[ib][nthreads - 1];
90		- for (ithread = nthreads - 1; ithread > 0; ithread--) {
91		- ntri_th[ib][ithread] = ntri_th[ib][ithread - 1];
92		- }
93		- ntri_th[ib][0] = 0;
94		- }
95		- printf(" band # of nodeline\n");
96		- for (ib = 0; ib < nb; ib++) {
97		- printf(" %d %d\n", ib + 1, nnl[ib]);
98		- }
99		- /*
100	118	Allocation of nodeline
101	119	*/
102		- kvnl = (GLfloat***)malloc(nb sizeof(GLfloat***));
103		- kvnl_rot = (GLfloat***)malloc(nb sizeof(GLfloat***));
104		- for (ib = 0; ib < nb; ++ib) {
105		- kvnl[ib] = (GLfloat**)malloc(nnl[ib] sizeof(GLfloat**));
106		- kvnl_rot[ib] = (GLfloat**)malloc(nnl[ib] sizeof(GLfloat**));
107		- for (i = 0; i < nnl[ib]; ++i) {
108		- kvnl[ib][i] = (GLfloat*)malloc(2 sizeof(GLfloat*));
109		- kvnl_rot[ib][i] = (GLfloat*)malloc(2 sizeof(GLfloat*));
110		- for (j = 0; j < 2; ++j) {
111		- kvnl[ib][i][j] = (GLfloat)malloc(3 sizeof(GLfloat));
112		- kvnl_rot[ib][i][j] = (GLfloat)malloc(3 sizeof(GLfloat));
	120	+ if (query == 1) {
	121	+ /*
	122	+ Sum node-lines in all threads
	123	+ */
	124	+ for (ib = 0; ib < nb; ib++) {
	125	+ for (ithread = 1; ithread < nthreads; ithread++) {
	126	+ ntri_th[ib][ithread] += ntri_th[ib][ithread - 1];
113	127	}
114		- }
115		- }
116		- /**/
117		-#pragma omp parallel default(none) \
118		- shared(nb,nnl,matp,kvnl,kvp,ntri,ntri_th) \
119		- private(ib,itri,mprod,i,nnl0,ithread)
120		- {
121		- ithread = get_thread();
	128	+ nnl[ib] = ntri_th[ib][nthreads - 1];
	129	+ for (ithread = nthreads - 1; ithread > 0; ithread--) {
	130	+ ntri_th[ib][ithread] = ntri_th[ib][ithread - 1];
	131	+ }
	132	+ ntri_th[ib][0] = 0;
	133	+ }/for (ib = 0; ib < nb; ib++)/
	134	+ printf(" band # of nodeline\n");
122	135	for (ib = 0; ib < nb; ib++) {
123		- nnl0 = ntri_th[ib][ithread];
124		-#pragma omp for
125		- for (itri = 0; itri < ntri[ib]; ++itri) {
126		- /**/
127		- mprod[0] = matp[ib][itri][0] * matp[ib][itri][1];
128		- mprod[1] = matp[ib][itri][1] * matp[ib][itri][2];
129		- /**/
130		- if (fabsf(matp[ib][itri][0]) < 0.00001 && fabsf(matp[ib][itri][1]) < 0.00001) {
131		- for (i = 0; i<3; ++i)kvnl[ib][nnl0][0][i] = kvp[ib][itri][0][i];
132		- for (i = 0; i<3; ++i)kvnl[ib][nnl0][1][i] = kvp[ib][itri][1][i];
133		- nnl0 += 1;
134		- }
135		- else if (fabsf(matp[ib][itri][0]) < 0.00001 && fabsf(matp[ib][itri][2]) < 0.00001) {
136		- for (i = 0; i<3; ++i)kvnl[ib][nnl0][0][i] = kvp[ib][itri][0][i];
137		- for (i = 0; i<3; ++i)kvnl[ib][nnl0][1][i] = kvp[ib][itri][2][i];
138		- nnl0 += 1;
139		- }
140		- else if (fabsf(matp[ib][itri][1]) < 0.00001 && fabsf(matp[ib][itri][2]) < 0.00001) {
141		- for (i = 0; i<3; ++i)kvnl[ib][nnl0][0][i] = kvp[ib][itri][1][i];
142		- for (i = 0; i<3; ++i)kvnl[ib][nnl0][1][i] = kvp[ib][itri][2][i];
143		- nnl0 += 1;
144		- }
145		- else if (mprod[0] < 0.0) {
146		- if (mprod[1] < 0.0) {
147		- for (i = 0; i<3; ++i)kvnl[ib][nnl0][0][i] =
148		- (matp[ib][itri][0] * kvp[ib][itri][1][i] - matp[ib][itri][1] * kvp[ib][itri][0][i])
149		- / (matp[ib][itri][0] - matp[ib][itri][1]);
150		- for (i = 0; i<3; ++i)kvnl[ib][nnl0][1][i] =
151		- (matp[ib][itri][1] * kvp[ib][itri][2][i] - matp[ib][itri][2] * kvp[ib][itri][1][i])
152		- / (matp[ib][itri][1] - matp[ib][itri][2]);
153		- nnl0 += 1;
154		- }
155		- else {
156		- for (i = 0; i<3; ++i)kvnl[ib][nnl0][0][i] =
157		- (matp[ib][itri][0] * kvp[ib][itri][1][i] - matp[ib][itri][1] * kvp[ib][itri][0][i])
158		- / (matp[ib][itri][0] - matp[ib][itri][1]);
159		- for (i = 0; i<3; ++i)kvnl[ib][nnl0][1][i] =
160		- (matp[ib][itri][0] * kvp[ib][itri][2][i] - matp[ib][itri][2] * kvp[ib][itri][0][i])
161		- / (matp[ib][itri][0] - matp[ib][itri][2]);
162		- nnl0 += 1;
163		- }
164		- }
165		- else if (mprod[1] < 0.0) {
166		- for (i = 0; i<3; ++i)kvnl[ib][nnl0][0][i] =
167		- (matp[ib][itri][0] * kvp[ib][itri][2][i] - matp[ib][itri][2] * kvp[ib][itri][0][i])
168		- / (matp[ib][itri][0] - matp[ib][itri][2]);
169		- for (i = 0; i<3; ++i)kvnl[ib][nnl0][1][i] =
170		- (matp[ib][itri][1] * kvp[ib][itri][2][i] - matp[ib][itri][2] * kvp[ib][itri][1][i])
171		- / (matp[ib][itri][1] - matp[ib][itri][2]);
172		- nnl0 += 1;
173		- }
174		- }/for (itri = 0; itri < ntri[ib]; ++itri)/
	136	+ printf(" %d %d\n", ib + 1, nnl[ib]);
175	137	}/for (ib = 0; ib < nb; ib++)/
176		- }/* End of parallel region */
	138	+ /*
	139	+ Allocation of nodeline
	140	+ */
	141	+ kvnl = (GLfloat***)malloc(nb sizeof(GLfloat***));
	142	+ kvnl_rot = (GLfloat***)malloc(nb sizeof(GLfloat***));
	143	+ for (ib = 0; ib < nb; ++ib) {
	144	+ kvnl[ib] = (GLfloat**)malloc(nnl[ib] sizeof(GLfloat**));
	145	+ kvnl_rot[ib] = (GLfloat**)malloc(nnl[ib] sizeof(GLfloat**));
	146	+ for (i = 0; i < nnl[ib]; ++i) {
	147	+ kvnl[ib][i] = (GLfloat*)malloc(2 sizeof(GLfloat*));
	148	+ kvnl_rot[ib][i] = (GLfloat*)malloc(2 sizeof(GLfloat*));
	149	+ for (j = 0; j < 2; ++j) {
	150	+ kvnl[ib][i][j] = (GLfloat)malloc(3 sizeof(GLfloat));
	151	+ kvnl_rot[ib][i][j] = (GLfloat)malloc(3 sizeof(GLfloat));
	152	+ }/for (j = 0; j < 2; ++j)/
	153	+ }/for (i = 0; i < nnl[ib]; ++i)/
	154	+ }/for (ib = 0; ib < nb; ++ib)/
	155	+ }/if (query == 1)/
177	156	}/void calc_nodeline()/

--- a/src/draw.c

+++ b/src/draw.c

		@@ -34,7 +34,7 @@ THE SOFTWARE.
34	34	/**
35	35	Draw Fermi surfaces
36	36	*/
37		-void draw_fermi() {
	37	+static void draw_fermi() {
38	38	int i, j, ib, itri;
39	39	GLfloat vect[3];
40	40	/*

		@@ -128,7 +128,7 @@ void draw_fermi() {
128	128	/**
129	129	Draw lines of BZ boundaries
130	130	*/
131		-void draw_bz_lines() {
	131	+static void draw_bz_lines() {
132	132	int ibzl, i, j;
133	133	GLfloat bzl2[3], bvec2[3][3], linecolor[4];
134	134	/*

		@@ -167,7 +167,8 @@ void draw_bz_lines() {
167	167	for (j = 0; j < 3; ++j) {
168	168	bvec2[i][j] = rot[j][0] * bvec[i][0]
169	169	+ rot[j][1] * bvec[i][1]
170		- + rot[j][2] * bvec[i][2];
	170	+ + rot[j][2] * bvec[i][2]
	171	+ + trans[j];
171	172	}
172	173	}
173	174	glBegin(GL_LINE_STRIP);

		@@ -190,14 +191,29 @@ void draw_bz_lines() {
190	191	for (i = 0; i<3; ++i) bzl2[i] = trans[i] + bvec2[0][i] + bvec2[1][i]; glVertex3fv(bzl2);
191	192	glEnd();
192	193	}
193		- /**/
	194	+ /*
	195	+ Section for the 2D Fermi line
	196	+ */
	197	+ if (lsection == 1) {
	198	+ glBegin(GL_POLYGON);
	199	+ glNormal3fv(secvec);
	200	+ glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, white);
	201	+ for (ibzl = 0; ibzl < nbzl2d; ++ibzl) {
	202	+ for (j = 0; j < 3; ++j)
	203	+ bzl2[j] = rot[j][0] * bzl2d[ibzl][0]
	204	+ + rot[j][1] * bzl2d[ibzl][1]
	205	+ + rot[j][2] * bzl2d[ibzl][2]
	206	+ + trans[j];
	207	+ glVertex3fv(bzl2);
	208	+ }
	209	+ glEnd();
	210	+ }/if (lsection == 1)/
194	211	glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, black);
195		- /**/
196	212	} /* draw bz_lines */
197	213	/**
198	214	Draw color scale
199	215	*/
200		-void draw_colorbar()
	216	+static void draw_colorbar()
201	217	{
202	218	int i, j;
203	219	GLfloat mat2, barcolor[4];

		@@ -301,7 +317,7 @@ void draw_colorbar()
301	317	/**
302	318	Draw points for the stereogram
303	319	*/
304		-void draw_circles() {
	320	+static void draw_circles(double dx2d) {
305	321	int i;
306	322	GLfloat r;
307	323	/**/

		@@ -318,30 +334,53 @@ void draw_circles() {
318	334	/**/
319	335	glBegin(GL_TRIANGLE_FAN);
320	336	glNormal3f(0.0, 0.0, 1.0);
321		- glVertex3f(0.7, scl, 0.0);
	337	+ glVertex3f(0.7 - dx2d, scl, 0.0);
322	338	for (i = 0; i <= 20; i++) {
323		- glVertex3f(r * cos((GLfloat)i / 20.0 * 6.283185307) + 0.7,
	339	+ glVertex3f(r * cos((GLfloat)i / 20.0 * 6.283185307) + 0.7 - dx2d,
324	340	r * sin((GLfloat)i / 20.0 * 6.283185307) + scl, 0.0);
325	341	}
326	342	glEnd();
327	343	/**/
328	344	glBegin(GL_TRIANGLE_FAN);
329	345	glNormal3f(0.0, 0.0, 1.0);
330		- glVertex3f(-0.7, scl, 0.0);
	346	+ glVertex3f(-0.7 - dx2d, scl, 0.0);
331	347	for (i = 0; i <= 20; i++) {
332		- glVertex3f(r * cos((GLfloat)i / 20.0 * 6.283185307) - 0.7,
	348	+ glVertex3f(r * cos((GLfloat)i / 20.0 * 6.283185307) - 0.7 - dx2d,
333	349	r * sin((GLfloat)i / 20.0 * 6.283185307) + scl, 0.0);
334	350	}
335	351	glEnd();
336	352	}/void draw_circles/
337	353	/**
	354	+ Draw Fermi lines
	355	+*/
	356	+static void draw_fermi_line() {
	357	+ int i, ib, itri;
	358	+ GLfloat vect[3];
	359	+
	360	+ glLineWidth(2.0);
	361	+ glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, black);
	362	+ glBegin(GL_LINES);
	363	+ for (ib = 0; ib < nb; ib++) {
	364	+ if (draw_band[ib] == 1) {
	365	+ for (itri = 0; itri < n2d[ib]; ++itri) {
	366	+ for (i = 0; i < 2; ++i) {
	367	+ glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, clr2d[ib][itri][i]);
	368	+ glVertex3fv(kv2d[ib][itri][i]);
	369	+ }/for (i = 0; i < 2; ++i)/
	370	+ }/for (itri = 0; itri < nnl[ib]; ++itri)/
	371	+ }/if (draw_band[ib] == 1)/
	372	+ }/* for (ib = 0; ib < nb; ib++)*/
	373	+ glEnd();
	374	+ glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, black);
	375	+}/void draw_fermi_line/
	376	+ /**
338	377	Glut Display function
339	378	*/
340	379	void display()
341	380	{
342	381	GLfloat pos[] = { 1.0, 1.0, 1.0, 0.0 };
343	382	GLfloat amb[] = { 0.2, 0.2, 0.2, 0.0 };
344		- double dx, theta, posz, phi;
	383	+ double dx, dx2d, theta, posz, phi;
345	384	GLfloat pos1[4], pos2[4];
346	385	/**/
347	386	if (lstereo == 2) {

		@@ -380,6 +419,8 @@ void display()
380	419	theta = 0.0;
381	420	dx = 0.0;
382	421	}
	422	+ if (lsection == 1) dx2d = 0.7;
	423	+ else dx2d = 0.0;
383	424	/*
384	425	Initialize
385	426	*/

		@@ -394,6 +435,7 @@ void display()
394	435	*/
395	436	if (lstereo == 1) {
396	437	glLightfv(GL_LIGHT0, GL_POSITION, pos);
	438	+ glTranslated(-dx2d, 0.0, 0.0);
397	439	/*
398	440	Draw color scale
399	441	*/

		@@ -401,8 +443,8 @@ void display()
401	443	}
402	444	else {
403	445	glLightfv(GL_LIGHT0, GL_POSITION, pos1);
404		- draw_circles();
405		- glTranslated(-dx, 0.0, 0.0);
	446	+ draw_circles(dx2d);
	447	+ glTranslated(-dx-dx2d, 0.0, 0.0);
406	448	glRotated(theta, 0.0, 1.0, 0.0);
407	449	}
408	450	glLightfv(GL_LIGHT1, GL_AMBIENT, amb);

		@@ -427,7 +469,7 @@ void display()
427	469	gluLookAt(0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
428	470	glLightfv(GL_LIGHT0, GL_POSITION, pos2);
429	471	/**/
430		- glTranslated(dx, 0.0, 0.0);
	472	+ glTranslated(dx-dx2d, 0.0, 0.0);
431	473	glRotated(-theta, 0.0, 1.0, 0.0);
432	474	/**/
433	475	glScaled(scl, scl, scl);

		@@ -436,6 +478,22 @@ void display()
436	478	/**/
437	479	glPopMatrix();
438	480	}
439		- /**/
	481	+ /*
	482	+ Draw 2D Fermi line
	483	+ */
	484	+ if (lsection == 1) {
	485	+ glPushMatrix();
	486	+ glLoadIdentity();
	487	+ gluLookAt(0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
	488	+ glLightfv(GL_LIGHT0, GL_POSITION, pos);
	489	+ /**/
	490	+ if (lstereo == 1) glTranslated(dx2d, 0.0, 0.0);
	491	+ else glTranslated(2.0 * dx2d, 0.0, 0.0);
	492	+ /**/
	493	+ glScaled(scl, scl, scl);
	494	+ draw_fermi_line();
	495	+ /**/
	496	+ glPopMatrix();
	497	+ }/if (lsection == 1)/
440	498	glutSwapBuffers();
441	499	}/void display/

--- a/src/fermisurfer.c

+++ b/src/fermisurfer.c

		@@ -51,6 +51,7 @@ with a color plot of the arbitraly matrix element
51	51	#include "calc_nodeline.h"
52	52	#include "bz_lines.h"
53	53	#include "free_patch.h"
	54	+#include "section.h"
54	55
55	56	#if defined(MAC)
56	57	#include <GLUT/glut.h>

		@@ -116,20 +117,17 @@ int main(
116	117	init_corner();
117	118	bragg_vector();
118	119	/**/
119		- query = 1;
120		- bz_lines();
121		- query = 0;
122	120	bz_lines();
123	121	/**/
124	122	max_and_min_bz();
125	123	/**/
126		- query = 1;
127		- fermi_patch();
128		- query = 0;
129		- fermi_patch();
130		- calc_nodeline();
131		- /**/
	124	+ query = 1; fermi_patch();
	125	+ query = 0; fermi_patch();
132	126	max_and_min();
	127	+ query = 1; calc_nodeline();
	128	+ query = 0; calc_nodeline();
	129	+ query = 1; calc_section();
	130	+ query = 0; calc_section();
133	131	/*
134	132	Description
135	133	*/

--- a/src/free_patch.c

+++ b/src/free_patch.c

		@@ -33,7 +33,9 @@ THE SOFTWARE.
33	33	*/
34	34	void free_patch() {
35	35	int ib, i0, i1;
36		-
	36	+ /*
	37	+ Fermi patch
	38	+ */
37	39	for (ib = 0; ib < nb; ++ib) {
38	40	for (i0 = 0; i0 < ntri[ib]; ++i0) {
39	41	for (i1 = 0; i1 < 3; ++i1) {

		@@ -61,21 +63,40 @@ void free_patch() {
61	63	free(kvp);
62	64	free(nmlp_rot);
63	65	free(kvp_rot);
64		-
	66	+ /*
	67	+ Nodal line
	68	+ */
65	69	for (ib = 0; ib < nb; ++ib) {
66	70	for (i0 = 0; i0 < nnl[ib]; ++i0) {
67	71	for (i1 = 0; i1 < 2; ++i1) {
68	72	free(kvnl[ib][i0][i1]);
69	73	free(kvnl_rot[ib][i0][i1]);
70		- }
	74	+ }/for (i1 = 0; i1 < 2; ++i1)/
71	75	free(kvnl[ib][i0]);
72	76	free(kvnl_rot[ib][i0]);
73		- }
	77	+ }/for (i0 = 0; i0 < nnl[ib]; ++i0)/
74	78	free(kvnl[ib]);
75	79	free(kvnl_rot[ib]);
76		- }
	80	+ }/for (ib = 0; ib < nb; ++ib)/
77	81	free(kvnl);
78	82	free(kvnl_rot);
	83	+ /*
	84	+ 2D Fermi line
	85	+ */
	86	+ for (ib = 0; ib < nb; ++ib) {
	87	+ for (i0 = 0; i0 < n2d[ib]; ++i0) {
	88	+ for (i1 = 0; i1 < 2; ++i1) {
	89	+ free(kv2d[ib][i0][i1]);
	90	+ free(clr2d[ib][i0][i1]);
	91	+ }/for (i1 = 0; i1 < 2; ++i1)/
	92	+ free(kv2d[ib][i0]);
	93	+ free(clr2d[ib][i0]);
	94	+ }/for (i0 = 0; i0 < n2d[ib]; ++i0)/
	95	+ free(kv2d[ib]);
	96	+ free(clr2d[ib]);
	97	+ }/for (ib = 0; ib < nb; ++ib)/
	98	+ free(kv2d);
	99	+ free(clr2d);
79	100	}/void free_patch()/
80	101	/**
81	102	Compute Max. & Min. of matrix elements.

--- a/src/initialize.c

+++ b/src/initialize.c

		@@ -254,6 +254,7 @@ void initialize_val() {
254	254	lcolorbar = 1;
255	255	lstereo = 1;
256	256	lmouse = 1;
	257	+ lsection = 0;
257	258	itet = 0;
258	259	scl = 1.0;
259	260	trans[0] = 0.0; trans[1] = 0.0; trans[2] = 0.0;

--- a/src/menu.c

+++ b/src/menu.c

		@@ -30,6 +30,8 @@ THE SOFTWARE.
30	30	#include "fermi_patch.h"
31	31	#include "calc_nodeline.h"
32	32	#include "kumo.h"
	33	+#include "initialize.h"
	34	+#include "section.h"
33	35
34	36	#if defined(MAC)
35	37	#include <GLUT/glut.h>

		@@ -65,13 +67,6 @@ void main_menu(int value /*< [in] Selected menu/) {
65	67	free(mat);
66	68	free(ntri);
67	69	free(draw_band);
68		- for (ibzl = 0; ibzl < nbzl; ++ibzl) {
69		- for (i = 0; i < 2; ++i) {
70		- free(bzl[ibzl][i]);
71		- }
72		- free(bzl[ibzl]);
73		- }
74		- free(bzl);
75	70	free(nnl);
76	71	exit(0);
77	72	}

		@@ -105,13 +100,13 @@ void menu_shiftEF(int value /*< [in] Selected menu/)
105	100	if (ierr != 1) printf("error ! reading ef");
106	101	/**/
107	102	free_patch();
108		- query = 1;
109		- fermi_patch();
110		- query = 0;
111		- fermi_patch();
112		- calc_nodeline();
113		- /**/
	103	+ query = 1; fermi_patch();
	104	+ query = 0; fermi_patch();
114	105	max_and_min();
	106	+ query = 1; calc_nodeline();
	107	+ query = 0; calc_nodeline();
	108	+ query = 1; calc_section();
	109	+ query = 0; calc_section();
115	110	/**/
116	111	glutPostRedisplay();
117	112	}

		@@ -133,13 +128,13 @@ void menu_interpol(int value /*< [in] Selected menu/)
133	128	/**/
134	129	interpol_energy();
135	130	free_patch();
136		- query = 1;
137		- fermi_patch();
138		- query = 0;
139		- fermi_patch();
140		- calc_nodeline();
141		- /**/
	131	+ query = 1; fermi_patch();
	132	+ query = 0; fermi_patch();
142	133	max_and_min();
	134	+ query = 1; calc_nodeline();
	135	+ query = 0; calc_nodeline();
	136	+ query = 1; calc_section();
	137	+ query = 0; calc_section();
143	138	/**/
144	139	glutPostRedisplay();
145	140	}

		@@ -285,13 +280,13 @@ void menu_bzmode(int value /*<[in] Selected menu/) {
285	280	fbz = 1;
286	281	/**/
287	282	free_patch();
288		- query = 1;
289		- fermi_patch();
290		- query = 0;
291		- fermi_patch();
292		- calc_nodeline();
293		- /**/
	283	+ query = 1; fermi_patch();
	284	+ query = 0; fermi_patch();
294	285	max_and_min();
	286	+ query = 1; calc_nodeline();
	287	+ query = 0; calc_nodeline();
	288	+ query = 1; calc_section();
	289	+ query = 0; calc_section();
295	290	/**/
296	291	glutPostRedisplay();
297	292	}

		@@ -299,13 +294,13 @@ void menu_bzmode(int value /*<[in] Selected menu/) {
299	294	fbz = -1;
300	295	/**/
301	296	free_patch();
302		- query = 1;
303		- fermi_patch();
304		- query = 0;
305		- fermi_patch();
306		- calc_nodeline();
307		- /**/
	297	+ query = 1; fermi_patch();
	298	+ query = 0; fermi_patch();
308	299	max_and_min();
	300	+ query = 1; calc_nodeline();
	301	+ query = 0; calc_nodeline();
	302	+ query = 1; calc_section();
	303	+ query = 0; calc_section();
309	304	/**/
310	305	glutPostRedisplay();
311	306	}

		@@ -341,6 +336,61 @@ void menu_stereo(int value /*<[in] Selected menu/) {
341	336	}
342	337	} /* menu_stereo */
343	338	/**
	339	+ Menu for 2D Fermi lines
	340	+*/
	341	+void menu_section(int value) /*<[in] Selected menu/ {
	342	+ int ierr, ii, jj, ib;
	343	+ GLfloat vec[3];
	344	+
	345	+ if (value == 1) {
	346	+ if (lsection != 1) {
	347	+ lsection = 1;
	348	+ glutPostRedisplay();
	349	+ }
	350	+ else {
	351	+ lsection = 0;
	352	+ glutPostRedisplay();
	353	+ }
	354	+ }/if (value == 1)/
	355	+ else if (value > 1) {
	356	+ if (value == 2) secscale = 1.0;
	357	+ else secscale = 0.0;
	358	+
	359	+ printf(" New Millor index : ");
	360	+ ierr = scanf("%f %f %f", &vec[0], &vec[1], &vec[2]);
	361	+ /*
	362	+ Fractional -> Cartecian
	363	+ */
	364	+ for (ii = 0; ii < 3; ii++) {
	365	+ secvec[ii] = 0.0;
	366	+ for (jj = 0; jj < 3; jj++) {
	367	+ secvec[ii] += vec[jj] * bvec[jj][ii];
	368	+ }/for (jj = 0; jj < 3; jj++)/
	369	+ }/for (ii = 0; ii < 3; ii++)/
	370	+ /*
	371	+ Free variables for Fermi line
	372	+ */
	373	+ for (ib = 0; ib < nb; ++ib) {
	374	+ for (ii = 0; ii < n2d[ib]; ++ii) {
	375	+ for (jj = 0; jj < 2; ++jj) {
	376	+ free(kv2d[ib][ii][jj]);
	377	+ free(clr2d[ib][ii][jj]);
	378	+ }/for (jj = 0; jj < 2; ++jj)/
	379	+ free(kv2d[ib][ii]);
	380	+ free(clr2d[ib][ii]);
	381	+ }/for (ii = 0; ii < n2d[ib]; ++ii)/
	382	+ free(kv2d[ib]);
	383	+ free(clr2d[ib]);
	384	+ }/for (ib = 0; ib < nb; ++ib)/
	385	+ free(kv2d);
	386	+ free(clr2d);
	387	+
	388	+ query = 1; calc_section();
	389	+ query = 0; calc_section();
	390	+ glutPostRedisplay();
	391	+ }/else if (value > 1)/
	392	+} /void menu_section/
	393	+/**
344	394	On/Off Colorbar
345	395	*/
346	396	void menu_colorbar(int value /*<[in] Selected menu/) {

		@@ -363,12 +413,13 @@ void menu_tetra(int value) /*<[in] Selected menu/ {
363	413	itet = value;
364	414	init_corner();
365	415	free_patch();
366		- query = 1;
367		- fermi_patch();
368		- query = 0;
369		- fermi_patch();
370		- calc_nodeline();
	416	+ query = 1; fermi_patch();
	417	+ query = 0; fermi_patch();
371	418	max_and_min();
	419	+ query = 1; calc_nodeline();
	420	+ query = 0; calc_nodeline();
	421	+ query = 1; calc_section();
	422	+ query = 0; calc_section();
372	423	glutPostRedisplay();
373	424	}
374	425	} /* menu_tetra */

		@@ -473,6 +524,15 @@ void FS_ModifyMenu(int status)
473	524	if (lstereo == 3) glutAddMenuEntry("[x] Cross", 3);
474	525	else glutAddMenuEntry("[ ] Cross", 3);
475	526	/*
	527	+ 2D Fermi lines
	528	+ */
	529	+ glutSetMenu(imenu_section);
	530	+ for (ib = 0; ib < 3; ib++) glutRemoveMenuItem(1);
	531	+ if (lsection == 1) glutAddMenuEntry("[x] Section", 1);
	532	+ else glutAddMenuEntry("[ ] Section", 1);
	533	+ glutAddMenuEntry("Modify section", 2);
	534	+ glutAddMenuEntry("Modify section (across Gamma)", 3);
	535	+ /*
476	536	Tetrahedron
477	537	*/
478	538	glutSetMenu(imenu_tetra);

		@@ -584,6 +644,14 @@ void FS_CreateMenu()
584	644	if (lstereo == 3) glutAddMenuEntry("[x] Cross", 3);
585	645	else glutAddMenuEntry("[ ] Cross", 3);
586	646	/*
	647	+ 2D Fermi lines
	648	+ */
	649	+ imenu_section = glutCreateMenu(menu_section);
	650	+ if (lsection == 1) glutAddMenuEntry("[x] Section", 1);
	651	+ else glutAddMenuEntry("[ ] Section", 1);
	652	+ glutAddMenuEntry("Modify section", 2);
	653	+ glutAddMenuEntry("Modify section (across Gamma)", 3);
	654	+ /*
587	655	Tetrahedron
588	656	*/
589	657	imenu_tetra = glutCreateMenu(menu_tetra);

		@@ -607,6 +675,7 @@ void FS_CreateMenu()
607	675	glutAddSubMenu("Node lines", imenu_nodeline);
608	676	glutAddSubMenu("Color bar On/Off", imenu_colorbar);
609	677	glutAddSubMenu("Stereogram", imenu_stereo);
	678	+ glutAddSubMenu("Section", imenu_section);
610	679	glutAddSubMenu("Tetrahedron", imenu_tetra);
611	680	glutAddMenuEntry("Exit", 9);
612	681	glutAttachMenu(GLUT_RIGHT_BUTTON);

--- a/src/read_file.c

+++ b/src/read_file.c

		@@ -84,6 +84,7 @@ void read_file(char fname/<[in] fname Input file name/)
84	84	ntri_th = (int*)malloc(nb sizeof(int*));
85	85	for (ib = 0; ib < nb; ib++) ntri_th[ib] = (int)malloc(nthreads sizeof(int));
86	86	nnl = (int)malloc(nb sizeof(int));
	87	+ n2d = (int)malloc(nb sizeof(int));
87	88	draw_band = (int)malloc(nb sizeof(int));
88	89	for (ib = 0; ib < nb; ib++) draw_band[ib] = 1;
89	90	/*

		@@ -94,6 +95,8 @@ void read_file(char fname/<[in] fname Input file name/)
94	95	if (ierr == 0) printf("error ! reading bvec");
95	96	printf(" bvec %d : %f %f %f \n", i + 1, bvec[i][0], bvec[i][1], bvec[i][2]);
96	97	}
	98	+ for (i = 0; i < 3; ++i) secvec[i] = bvec[2][i];
	99	+ secscale = 0.0;
97	100	/*
98	101	Allocation of Kohn-Sham energies $ matrix elements
99	102	*/

--- a/src/variable.h

+++ b/src/variable.h

		@@ -56,16 +56,17 @@ int nodeline; /*< Switch for node lines /
56	56	int lcolorbar; /*< Switch for colorbar /
57	57	int lstereo; /*< Switch for the stereogram /
58	58	int lmouse; /*< Switch for the mouse function /
	59	+int lsection; /*< Switch for the 2D Fermi lines/
59	60	/*
60	61	Menu
61	62	*/
62		-int imenu_band, imenu_interpol, imenu_bgcolor, imenu_colorscale, imenu_bzmode,
	63	+int imenu_band, imenu_interpol, imenu_bgcolor, imenu_colorscale, imenu_bzmode, imenu_section,
63	64	imenu_nodeline, imenu_colorbar, imenu_tetra, imenu_stereo, imenu_mouse, imenu;
64	65	/*
65	66	Variables for Brillouin zone boundaries
66	67	*/
67	68	int nbzl; /*< The number of Lines of 1st Brillouin zone /
68		-GLfloat *bzl; /< Lines of 1st BZ [nbzl][2][3] */
	69	+GLfloat bzl[676][2][3]; /*< Lines of 1st BZ [nbzl(max:2626=676)][2][3] */
69	70	GLfloat bragg[26][3]; /*< Bragg plane vectors /
70	71	GLfloat brnrm[26]; /*< Norms of Bragg plane vectors /
71	72	/*

		@@ -88,6 +89,17 @@ int nnl; /< The number of nodeline /
88	89	GLfloat **kvnl; /< K-vector of nodeline [nb][nnl][2][3] */
89	90	GLfloat **kvnl_rot; /< K-vector of nodeline [nb][nnl][2][3] */
90	91	/*
	92	+ 2D Fermi line
	93	+*/
	94	+GLfloat secvec[3]; /*< k-vector to define section/
	95	+GLfloat secscale; /*0.0 or 1.0/
	96	+GLfloat axis2d[2][3]; /*< k-vector to define section/
	97	+int *n2d;
	98	+GLfloat **kv2d;/< k-vector for 2D plot[nb][n2d][2][2] */
	99	+GLfloat **clr2d; /< Matrix element for 2D plot[nb][n2d][2][4] */
	100	+int nbzl2d; /*< The number of Lines of 1st Brillouin zone /
	101	+GLfloat bzl2d[26][3]; /*< Lines of 1st BZ [nbzl2d(max:26)][3] /
	102	+/*
91	103	Variables for mouse & cursorkey
92	104	*/
93	105	GLfloat sx; /*< Scale of mouse movement /

Show on old repository browser