From 7a4919752a60a7d096c83c3d2112a38c41e0f0ac Mon Sep 17 00:00:00 2001 From: Greg Landrum Date: Mon, 8 Apr 2024 13:00:34 +0200 Subject: [PATCH] remove a bunch of compiler warnings (#41) * "modernization" and removing compiler warnings * more warning cleanup --------- Co-authored-by: Greg Landrum --- tightbind/COOP_stuff.c | 41 +++++----------------- tightbind/DOS_stuff.c | 35 +++++-------------- tightbind/FMO_stuff.c | 55 ++++++------------------------ tightbind/K_hamil.c | 14 +++----- tightbind/K_overlap_mat.c | 24 ++++--------- tightbind/R_hamil.c | 7 +--- tightbind/R_overlap_mat.c | 11 ++---- tightbind/Zmat.c | 5 ++- tightbind/avg_props.c | 71 ++++++++------------------------------ tightbind/bands.c | 24 +++++-------- tightbind/cboris.c | 7 +++- tightbind/charge_mat.c | 14 ++------ tightbind/chg_it.c | 10 ++---- tightbind/distance_mat.c | 25 ++++---------- tightbind/driver.c | 6 ++-- tightbind/electrostat.c | 29 ++++------------ tightbind/fileio.c | 48 ++++++-------------------- tightbind/genutil.c | 70 +++++++++---------------------------- tightbind/kpoints.c | 27 +++++---------- tightbind/main.c | 4 +-- tightbind/matrices.c | 10 ++---- tightbind/memory.c | 28 ++++++--------- tightbind/mod_mulliken.c | 11 ++---- tightbind/mov.c | 7 ++-- tightbind/muller.c | 10 ++---- tightbind/mulliken.c | 27 +++------------ tightbind/new3_fileio.c | 6 +--- tightbind/postprocess.c | 72 +++++++++++---------------------------- tightbind/princ_axes.c | 6 +--- tightbind/symmetry.c | 51 +++++++++++---------------- tightbind/test_driver.c | 2 +- tightbind/transforms.c | 48 +++++++------------------- tightbind/walsh.c | 18 +++------- 33 files changed, 210 insertions(+), 613 deletions(-) diff --git a/tightbind/COOP_stuff.c b/tightbind/COOP_stuff.c index 90055970..9d86c846 100644 --- a/tightbind/COOP_stuff.c +++ b/tightbind/COOP_stuff.c @@ -70,16 +70,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * Action: This evaluates and returns the actual COOP. * ****************************************************************************/ - real eval_COOP(COOP,details,cell,num_orbs,prop_info,R_overlaps,orbital_ordering, - orbital_lookup_table) - COOP_type *COOP; - detail_type *details; - cell_type *cell; - int num_orbs; - avg_prop_info_type *prop_info; - hermetian_matrix_type R_overlaps; - K_orb_ptr_type *orbital_ordering; - int *orbital_lookup_table; + real eval_COOP(COOP_type *COOP,detail_type *details,cell_type *cell,int num_orbs,avg_prop_info_type *prop_info,hermetian_matrix_type R_overlaps, + K_orb_ptr_type *orbital_ordering, + int *orbital_lookup_table) { static point_type *cell_dim=0; static real *overlap_store=0; @@ -673,15 +666,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * present in the expression for P_uv. * ****************************************************************************/ - void gen_COOP(details,cell,num_orbs,avg_prop_info,R_overlaps,orbital_ordering, - orbital_lookup_table) - detail_type *details; - cell_type *cell; - int num_orbs; - avg_prop_info_type *avg_prop_info; - hermetian_matrix_type R_overlaps; - K_orb_ptr_type *orbital_ordering; - int *orbital_lookup_table; + void gen_COOP(detail_type *details,cell_type *cell,int num_orbs,avg_prop_info_type *avg_prop_info,hermetian_matrix_type R_overlaps, + K_orb_ptr_type *orbital_ordering, + int *orbital_lookup_table) { int i,j; int tot_num_orbs,num_COOPS; @@ -849,15 +836,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * Everything here is done the same way as in gen_COOP * ****************************************************************************/ - void gen_avg_COOPs(details,cell,num_orbs,avg_prop_info,R_overlaps,orbital_ordering, - orbital_lookup_table) - detail_type *details; - cell_type *cell; - int num_orbs; - avg_prop_info_type *avg_prop_info; - hermetian_matrix_type R_overlaps; - K_orb_ptr_type *orbital_ordering; - int *orbital_lookup_table; + void gen_avg_COOPs(detail_type *details,cell_type *cell,int num_orbs,avg_prop_info_type *avg_prop_info,hermetian_matrix_type R_overlaps,K_orb_ptr_type *orbital_ordering, + int *orbital_lookup_table) { int i,j; int tot_num_orbs,num_COOPS; @@ -979,9 +959,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * ***********************************************/ -void intercell_COOP_check(COOP) - -COOP_type *COOP; +void intercell_COOP_check(COOP_type *COOP) { int temp; @@ -1008,4 +986,3 @@ COOP_type *COOP; COOP->cell.z *= -1.0; } } - diff --git a/tightbind/DOS_stuff.c b/tightbind/DOS_stuff.c index 609b47eb..ed45bb25 100644 --- a/tightbind/DOS_stuff.c +++ b/tightbind/DOS_stuff.c @@ -73,12 +73,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * ****************************************************************************/ -void gen_total_DOS(details,cell,num_orbs,avg_prop_info,orbital_ordering) - detail_type *details; - cell_type *cell; - int num_orbs; - avg_prop_info_type *avg_prop_info; - K_orb_ptr_type *orbital_ordering; +void gen_total_DOS(detail_type *details,cell_type *cell,int num_orbs,avg_prop_info_type *avg_prop_info,K_orb_ptr_type *orbital_ordering) { int i,j; int tot_num_orbs; @@ -217,10 +212,7 @@ void gen_total_DOS(details,cell,num_orbs,avg_prop_info,orbital_ordering) * This is just the charge matrix element for 'which_AO. * ****************************************************************************/ -real orb_contribution(num_orbs,kpoint,MO,avg_prop_info,which_AO) - int num_orbs,kpoint,MO; - avg_prop_info_type *avg_prop_info; - int which_AO; +real orb_contribution(int num_orbs,int kpoint,int MO,avg_prop_info_type *avg_prop_info,int which_AO) { real contrib; @@ -247,10 +239,7 @@ real orb_contribution(num_orbs,kpoint,MO,avg_prop_info,which_AO) * This is just the charge matrix element for 'which_FMO. * ****************************************************************************/ -real FMO_contribution(num_orbs,kpoint,MO,avg_prop_info,which_FMO) - int num_orbs,kpoint,MO; - avg_prop_info_type *avg_prop_info; - int which_FMO; +real FMO_contribution(int num_orbs,int kpoint,int MO,avg_prop_info_type *avg_prop_info,int which_FMO) { real contrib; @@ -279,11 +268,8 @@ real FMO_contribution(num_orbs,kpoint,MO,avg_prop_info,which_FMO) * 'which_atom to this MO. * ****************************************************************************/ -real atom_contribution(num_orbs,num_atoms,kpoint,MO,avg_prop_info,which_atom, - orbital_lookup_table) - int num_orbs,num_atoms,kpoint,MO; - avg_prop_info_type *avg_prop_info; - int which_atom,*orbital_lookup_table; +real atom_contribution(int num_orbs,int num_atoms,int kpoint,int MO,avg_prop_info_type *avg_prop_info,int which_atom, + int *orbital_lookup_table) { int i,atom_begin,atom_end; float *chg_mat_ptr; @@ -324,14 +310,9 @@ real atom_contribution(num_orbs,num_atoms,kpoint,MO,avg_prop_info,which_atom, * Action: Generates all of the projected DOS curves. * ****************************************************************************/ -void gen_projected_DOS(details,cell,num_orbs,avg_prop_info,orbital_ordering, - orbital_lookup_table) - detail_type *details; - cell_type *cell; - int num_orbs; - avg_prop_info_type *avg_prop_info; - K_orb_ptr_type *orbital_ordering; - int *orbital_lookup_table; +void gen_projected_DOS(detail_type *details,cell_type *cell,int num_orbs,avg_prop_info_type *avg_prop_info, + K_orb_ptr_type *orbital_ordering, + int *orbital_lookup_table) { int i,j,k,l; int tot_num_orbs,num_states,begin,end; diff --git a/tightbind/FMO_stuff.c b/tightbind/FMO_stuff.c index ec0b50a7..1b4f6b03 100644 --- a/tightbind/FMO_stuff.c +++ b/tightbind/FMO_stuff.c @@ -53,10 +53,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * Action: writes the header to the FMO output file. * ****************************************************************************/ -void init_FMO_file(details,num_orbs,num_electrons) - detail_type *details; - int num_orbs; - real num_electrons; +void init_FMO_file(detail_type *details,int num_orbs,real num_electrons) { int i; @@ -93,12 +90,7 @@ void init_FMO_file(details,num_orbs,num_electrons) * 'details. * ****************************************************************************/ -void build_FMO_overlap(details,num_orbs,num_atoms,overlap,orbital_lookup_table) - detail_type *details; - int num_orbs; - int num_atoms; - hermetian_matrix_type overlap; - int *orbital_lookup_table; +void build_FMO_overlap(detail_type *details,int num_orbs,int num_atoms,hermetian_matrix_type overlap,int *orbital_lookup_table) { FMO_frag_type *FMO_frag; int i,j; @@ -179,12 +171,7 @@ void build_FMO_overlap(details,num_orbs,num_atoms,overlap,orbital_lookup_table) * 'details. * ****************************************************************************/ -void build_FMO_hamil(details,num_orbs,num_atoms,hamil,orbital_lookup_table) - detail_type *details; - int num_orbs; - int num_atoms; - hermetian_matrix_type hamil; - int *orbital_lookup_table; +void build_FMO_hamil(detail_type *details,int num_orbs,int num_atoms,hermetian_matrix_type hamil,int *orbital_lookup_table) { FMO_frag_type *FMO_frag; int i,j; @@ -282,10 +269,7 @@ void build_FMO_hamil(details,num_orbs,num_atoms,hamil,orbital_lookup_table) * returns (they will not). * ****************************************************************************/ -void diagonalize_FMO(details,work1,work2,work3,cmplx_hamil,cmplx_overlap,cmplx_work) - detail_type *details; - real *work1,*work2,*work3; - complex *cmplx_hamil,*cmplx_overlap,*cmplx_work; +void diagonalize_FMO(detail_type *details,real *work1,real *work2,real *work3,complex *cmplx_hamil,complex *cmplx_overlap,complex *cmplx_work) { FMO_frag_type *FMO_frag; int i,j,k,itab,jtab,ktab; @@ -526,8 +510,7 @@ INCREASE to the right)\n"); * orbitals from the AO to the FMO basis. * ****************************************************************************/ -void gen_FMO_tform_matrices(details) - detail_type *details; +void gen_FMO_tform_matrices(detail_type *details) { FMO_frag_type *FMO_frag; real *matR, *matI; @@ -636,12 +619,7 @@ fprintf(output_file,"\n\n\n"); * below. * ****************************************************************************/ -void tform_wavefuncs_to_FMO_basis(details,num_orbs,num_atoms,eigenset,orbital_lookup_table) - detail_type *details; - int num_orbs; - int num_atoms; - eigenset_type eigenset; - int *orbital_lookup_table; +void tform_wavefuncs_to_FMO_basis(detail_type *details,int num_orbs,int num_atoms,eigenset_type eigenset,int *orbital_lookup_table) { FMO_frag_type *FMO_frag; @@ -773,14 +751,8 @@ fprintf(output_file,"\n\n\n"); * The results are placed in 'cmplx_mat. * ****************************************************************************/ -void tform_matrix_to_FMO_basis(details,num_orbs,num_atoms,AO_matR,AO_matI, - temp_matR,temp_matI,cmplx_mat,orbital_lookup_table) - detail_type *details; - int num_orbs; - int num_atoms; - real *AO_matR,*AO_matI,*temp_matR,*temp_matI; - complex_matrix_type cmplx_mat; - int *orbital_lookup_table; +void tform_matrix_to_FMO_basis(detail_type *details,int num_orbs,int num_atoms,real *AO_matR,real *AO_matI, + real *temp_matR,real *temp_matI,complex_matrix_type cmplx_mat,int *orbital_lookup_table) { FMO_frag_type *FMO_frag; @@ -968,15 +940,8 @@ fprintf(output_file,"\n\n\n"); * The results of the multiplication are put into the matrix 'results * ****************************************************************************/ -void tform_hermetian_matrix_to_FMO_basis(details,num_orbs,num_atoms,herm_mat, - temp_matR,temp_matI,results,orbital_lookup_table) - detail_type *details; - int num_orbs; - int num_atoms; - hermetian_matrix_type herm_mat; - real *temp_matR,*temp_matI; - hermetian_matrix_type results; - int *orbital_lookup_table; +void tform_hermetian_matrix_to_FMO_basis(detail_type *details,int num_orbs,int num_atoms,hermetian_matrix_type herm_mat, + real *temp_matR,real *temp_matI,hermetian_matrix_type results,int *orbital_lookup_table) { FMO_frag_type *FMO_frag; diff --git a/tightbind/K_hamil.c b/tightbind/K_hamil.c index b2201a59..4655779a 100644 --- a/tightbind/K_hamil.c +++ b/tightbind/K_hamil.c @@ -60,11 +60,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * ****************************************************************************/ -void build_k_hamil_FAT(cell,hamilR,hamilK,overlapK,num_orbs) - cell_type *cell; - hermetian_matrix_type hamilR,hamilK; - hermetian_matrix_type overlapK; - int num_orbs; +void build_k_hamil_FAT(cell_type *cell,hermetian_matrix_type hamilR,hermetian_matrix_type hamilK, + hermetian_matrix_type overlapK,int num_orbs) { int i,j; int itab,jtab; @@ -114,11 +111,8 @@ printmat(hamilK.mat,num_orbs,num_orbs,output_file,1e-6,details->line_width); * insignificant in terms of the diagonalization and building S(K). * ****************************************************************************/ -void build_k_hamil_THIN(cell,hamilR,hamilK,overlapK,num_orbs) - cell_type *cell; - hermetian_matrix_type hamilR,hamilK; - hermetian_matrix_type overlapK; - int num_orbs; +void build_k_hamil_THIN(cell_type *cell,hermetian_matrix_type hamilR,hermetian_matrix_type hamilK, + hermetian_matrix_type overlapK,int num_orbs) { int i,j; int itab,jtab; diff --git a/tightbind/K_overlap_mat.c b/tightbind/K_overlap_mat.c index 2a5f333c..4ddf2b4f 100644 --- a/tightbind/K_overlap_mat.c +++ b/tightbind/K_overlap_mat.c @@ -66,11 +66,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * k-point. * ****************************************************************************/ -void build_k_overlap_FAT(cell,kpoint,overlapR,overlapK,num_orbs) - cell_type *cell; - k_point_type *kpoint; - hermetian_matrix_type overlapR,overlapK; - int num_orbs; +void build_k_overlap_FAT(cell_type *cell,k_point_type *kpoint,hermetian_matrix_type overlapR,hermetian_matrix_type overlapK,int num_orbs) { int i,j,k,l,m; int itab,jtab,ktab; @@ -207,12 +203,8 @@ printmat(overlapK.mat,num_orbs,num_orbs,output_file,1e-6,details->line_width); * Action: This generates the overlap matrix for a given k-point * ****************************************************************************/ -void build_k_overlap_THIN(cell,details,kpoint,overlapR,overlapK,num_orbs) - cell_type *cell; - detail_type *details; - k_point_type *kpoint; - hermetian_matrix_type overlapR,overlapK; - int num_orbs; +void build_k_overlap_THIN(cell_type *cell,detail_type *details,k_point_type *kpoint, + hermetian_matrix_type overlapR,hermetian_matrix_type overlapK,int num_orbs) { int i,j,k,l,m; int itab,jtab,ktab; @@ -410,13 +402,9 @@ printmat(overlapK.mat,num_orbs,num_orbs,output_file,1e-6,details->line_width); * memory * ****************************************************************************/ -void build_all_K_overlaps(cell,details,overlapR,overlapK,num_orbs, - tot_overlaps,orbital_lookup_table) - cell_type *cell; - detail_type *details; - hermetian_matrix_type overlapR,overlapK; - int num_orbs,tot_overlaps; - int *orbital_lookup_table; +void build_all_K_overlaps(cell_type *cell,detail_type *details, + hermetian_matrix_type overlapR,hermetian_matrix_type overlapK,int num_orbs, + int tot_overlaps,int *orbital_lookup_table) { k_point_type *kpoint; int which_k; diff --git a/tightbind/R_hamil.c b/tightbind/R_hamil.c index 30420e93..34da90a9 100644 --- a/tightbind/R_hamil.c +++ b/tightbind/R_hamil.c @@ -65,12 +65,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * K space hamiltonian (the important one) is built. * ****************************************************************************/ -void R_space_Hamiltonian(cell,details,overlap,hamil,num_orbs,orbital_lookup_table) - cell_type *cell; - detail_type *details; - hermetian_matrix_type overlap,hamil; - int num_orbs; - int *orbital_lookup_table; +void R_space_Hamiltonian(cell_type *cell,detail_type *details,hermetian_matrix_type overlap,hermetian_matrix_type hamil,int num_orbs,int *orbital_lookup_table) { int i,j; int orb_tab1; diff --git a/tightbind/R_overlap_mat.c b/tightbind/R_overlap_mat.c index 0f433121..1130085d 100644 --- a/tightbind/R_overlap_mat.c +++ b/tightbind/R_overlap_mat.c @@ -893,14 +893,9 @@ printmat(overlap,num_orbs,num_orbs,status_file,1e-6,0,details->line_width); * * *****************************************************************************/ -void R_space_overlap_matrix(cell,details,overlap,num_orbs,tot_overlaps, - orbital_lookup_table,which_one) - cell_type *cell; - detail_type *details; - hermetian_matrix_type overlap; - int num_orbs,tot_overlaps; - int *orbital_lookup_table; - int which_one; +void R_space_overlap_matrix(cell_type *cell,detail_type *details,hermetian_matrix_type overlap, + int num_orbs,int tot_overlaps, + int *orbital_lookup_table,int which_one) { char err_string[240]; int overlaps_so_far; diff --git a/tightbind/Zmat.c b/tightbind/Zmat.c index 1250195f..c239c2a0 100644 --- a/tightbind/Zmat.c +++ b/tightbind/Zmat.c @@ -45,9 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. /* helper function to find a particular numbered atom in an array of atoms */ -int find_atom(atoms,num_atoms,which) - atom_type *atoms; - int num_atoms,which; +int find_atom(atom_type *atoms,int num_atoms,int which) { static char err_string[120]; int i; @@ -60,6 +58,7 @@ int find_atom(atoms,num_atoms,which) sprintf(err_string,"Can't find atom %d (of %d) in find_atom.\n", which,num_atoms); FATAL_BUG(err_string); + return(0); } diff --git a/tightbind/avg_props.c b/tightbind/avg_props.c index 86fd217d..f0eaf8fe 100644 --- a/tightbind/avg_props.c +++ b/tightbind/avg_props.c @@ -71,15 +71,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * The AO occupations are returned in AO_occups. * ****************************************************************************/ -void calc_avg_occups(details,cell,num_orbs,orbital_ordering,avg_prop_info, - properties,AO_occups) - detail_type *details; - cell_type *cell; - int num_orbs; - K_orb_ptr_type *orbital_ordering; - avg_prop_info_type *avg_prop_info; - prop_type *properties; - real *AO_occups; +void calc_avg_occups(detail_type *details,cell_type *cell,int num_orbs,K_orb_ptr_type *orbital_ordering,avg_prop_info_type *avg_prop_info, + prop_type *properties,real *AO_occups) { int i,j,k; real tot_num_K=0.0; @@ -191,15 +184,8 @@ void calc_avg_occups(details,cell,num_orbs,orbital_ordering,avg_prop_info, * net charges on all the atoms, to the output file. * ****************************************************************************/ -void print_avg_occups(details,cell,num_orbs,orbital_ordering,avg_prop_info, - properties,AO_occups) - detail_type *details; - cell_type *cell; - int num_orbs; - K_orb_ptr_type *orbital_ordering; - avg_prop_info_type *avg_prop_info; - prop_type properties; - real *AO_occups; +void print_avg_occups(detail_type *details,cell_type *cell,int num_orbs,K_orb_ptr_type *orbital_ordering,avg_prop_info_type *avg_prop_info, + prop_type properties,real *AO_occups) { int i,j,k,f_occup_print=0; real tot_num_K=0.0; @@ -342,13 +328,8 @@ void print_avg_occups(details,cell,num_orbs,orbital_ordering,avg_prop_info, * The FMO occupations are returned in FMO_occups. * ****************************************************************************/ -void calc_avg_FMO_occups(details,num_orbs,orbital_ordering,avg_prop_info, - FMO_occups) - detail_type *details; - int num_orbs; - K_orb_ptr_type *orbital_ordering; - avg_prop_info_type *avg_prop_info; - real *FMO_occups; +void calc_avg_FMO_occups(detail_type *details,int num_orbs,K_orb_ptr_type *orbital_ordering,avg_prop_info_type *avg_prop_info, + real *FMO_occups) { int i,j,k; real tot_num_K=0.0; @@ -466,15 +447,8 @@ void calc_avg_FMO_occups(details,num_orbs,orbital_ordering,avg_prop_info, * stored in the appropriate places in 'properties. * ****************************************************************************/ -void calc_avg_OP(details,cell,num_orbs,orbital_ordering,avg_prop_info, - overlapR,properties) - detail_type *details; - cell_type *cell; - int num_orbs; - K_orb_ptr_type *orbital_ordering; - avg_prop_info_type *avg_prop_info; - hermetian_matrix_type overlapR; - prop_type properties; +void calc_avg_OP(detail_type *details,cell_type *cell,int num_orbs,K_orb_ptr_type *orbital_ordering,avg_prop_info_type *avg_prop_info, + hermetian_matrix_type overlapR,prop_type properties) { int i,j,k,l; real tot_num_K=0.0; @@ -637,13 +611,8 @@ void calc_avg_OP(details,cell,num_orbs,orbital_ordering,avg_prop_info, * The Fermi Energy is stored in the the variable 'Fermi_E. * ****************************************************************************/ -void find_crystal_occupations(details,electrons_per_cell,num_orbs, - orbital_ordering,Fermi_E) - detail_type *details; - real electrons_per_cell; - int num_orbs; - K_orb_ptr_type *orbital_ordering; - real *Fermi_E; +void find_crystal_occupations(detail_type *details,real electrons_per_cell,int num_orbs, + K_orb_ptr_type *orbital_ordering,real *Fermi_E) { int i; int tot_orbs; @@ -773,15 +742,8 @@ void find_crystal_occupations(details,electrons_per_cell,num_orbs, * in the file indicated by the element (depending on execution mode) * ****************************************************************************/ -void store_avg_prop_info(details,which_k,eigenset,overlap,num_orbs, - chg_mat,avg_prop_info) - detail_type *details; - int which_k; - eigenset_type eigenset; - hermetian_matrix_type overlap; - int num_orbs; - real *chg_mat; - avg_prop_info_type *avg_prop_info; +void store_avg_prop_info(detail_type *details,int which_k,eigenset_type eigenset,hermetian_matrix_type overlap,int num_orbs, + real *chg_mat,avg_prop_info_type *avg_prop_info) { int i,j; int itab,jtab; @@ -834,8 +796,7 @@ void store_avg_prop_info(details,which_k,eigenset,overlap,num_orbs, orbital energies. *******/ -int sort_energies_helper(orb1,orb2) - const void *orb1, *orb2; +int sort_energies_helper(const void *orb1,const void *orb2) { real diff; @@ -871,11 +832,7 @@ int sort_energies_helper(orb1,orb2) * point to their energies within the avg_prop_info array is sorted. * ****************************************************************************/ -void sort_avg_prop_info(details,num_orbs,avg_prop_info,orbital_ordering) - detail_type *details; - int num_orbs; - avg_prop_info_type *avg_prop_info; - K_orb_ptr_type *orbital_ordering; +void sort_avg_prop_info(detail_type *details,int num_orbs,avg_prop_info_type *avg_prop_info,K_orb_ptr_type *orbital_ordering) { int i,j; int itab; diff --git a/tightbind/bands.c b/tightbind/bands.c index 1857df6c..8d2e8e7f 100644 --- a/tightbind/bands.c +++ b/tightbind/bands.c @@ -67,8 +67,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * Action: Automagically generates the kpoints along each symmetry line. * ****************************************************************************/ -void gen_symm_lines(bands) - band_info_type *bands; +void gen_symm_lines(band_info_type *bands) { int i,j; int points_per_line; @@ -159,20 +158,13 @@ void gen_symm_lines(bands) * are generated. Efficiency! * ****************************************************************************/ -void construct_band_structure(cell,details,overlapR,hamilR,overlapK,hamilK, - cmplx_hamil,cmplx_overlap, - eigenset,work1,work2,work3,cmplx_work, - num_orbs,orbital_lookup_table) - cell_type *cell; - detail_type *details; - hermetian_matrix_type overlapR,hamilR; - hermetian_matrix_type overlapK,hamilK; - complex *cmplx_hamil,*cmplx_overlap; - eigenset_type eigenset; - real *work1,*work2,*work3; - complex *cmplx_work; - int num_orbs; - int *orbital_lookup_table; +void construct_band_structure(cell_type *cell,detail_type *details, + hermetian_matrix_type overlapR,hermetian_matrix_type hamilR, + hermetian_matrix_type overlapK,hermetian_matrix_type hamilK, + complex *cmplx_hamil,complex *cmplx_overlap, + eigenset_type eigenset,real *work1,real *work2,real *work3, + complex *cmplx_work, + int num_orbs,int *orbital_lookup_table) { static char (*label)[4]=0; k_point_type *kpoint; diff --git a/tightbind/cboris.c b/tightbind/cboris.c index dbc4e34b..af1c7aac 100644 --- a/tightbind/cboris.c +++ b/tightbind/cboris.c @@ -6,7 +6,12 @@ Produced by gmFortran V30.59(10/26/17) on 9/18/18 at 9:02:32 void cboris(int *n,int *nd,double *a,double *b,double *c,double *d,double *e, double *f,int *fail) { -extern void cchol(),ctred2(),ctql2(); + + +extern void cchol(int *n,int *nd,double *a,int *fail); +extern void ctred2(int *n,int *nd,double *a,double *b,double *d,double *e,double *f); +extern void ctql2(int *n,int *nd,double *d,double *e,double *f,double *a,double *b, + int *fail); static int lf,i,ia,j,k,ja,ii; /* diff --git a/tightbind/charge_mat.c b/tightbind/charge_mat.c index e8da27b2..3ab8c98e 100644 --- a/tightbind/charge_mat.c +++ b/tightbind/charge_mat.c @@ -68,13 +68,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ahhhhh, the suffering one must do for execution speed. :-) * ****************************************************************************/ -void eval_charge_matrix(cell,eigenset,overlap,num_orbs, - orbital_lookup_table,chg_matrix,accum) - cell_type *cell; - eigenset_type eigenset; - hermetian_matrix_type overlap; - int num_orbs,*orbital_lookup_table; - real *chg_matrix,*accum; +void eval_charge_matrix(cell_type *cell,eigenset_type eigenset,hermetian_matrix_type overlap,int num_orbs, + int *orbital_lookup_table,real *chg_matrix,real *accum) { int num_atoms; int i,j,k,l; @@ -159,10 +154,7 @@ void eval_charge_matrix(cell,eigenset,overlap,num_orbs, * num_atoms * num_orbs * ****************************************************************************/ -void reduced_charge_mat(num_atoms,num_orbs,orbital_lookup_table,Chg_matrix,RChg_matrix) - int num_atoms,num_orbs,*orbital_lookup_table; - real *Chg_matrix; - real *RChg_matrix; +void reduced_charge_mat(int num_atoms,int num_orbs,int *orbital_lookup_table,real *Chg_matrix,real *RChg_matrix) { int i,j,k,l; int ktab; diff --git a/tightbind/chg_it.c b/tightbind/chg_it.c index d5d1b41e..b2b72d46 100644 --- a/tightbind/chg_it.c +++ b/tightbind/chg_it.c @@ -60,14 +60,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * atomic Hii's using the charge iteration formula. * ****************************************************************************/ -void update_chg_it_parms(details,cell,AO_occups,converged,num_orbs, - orbital_lookup_table) - detail_type *details; - cell_type *cell; - real *AO_occups; - int *converged; - int num_orbs; - int *orbital_lookup_table; +void update_chg_it_parms(detail_type *details,cell_type *cell,real *AO_occups,int *converged,int num_orbs, + int *orbital_lookup_table) { static real *AO_store=0; static int num_calls=0; diff --git a/tightbind/distance_mat.c b/tightbind/distance_mat.c index bf7f7014..eb2381e2 100644 --- a/tightbind/distance_mat.c +++ b/tightbind/distance_mat.c @@ -64,12 +64,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * out in the output file. * *****************************************************************************/ -void check_a_cell(atoms,vect,num_atoms,closest_nn_contact,descriptor) - atom_type *atoms; - point_type vect; - int num_atoms; - real closest_nn_contact; - char *descriptor; +void check_a_cell(atom_type *atoms,point_type vect,int num_atoms,real closest_nn_contact,char *descriptor) { int i,j; real min_squared; @@ -118,9 +113,7 @@ void check_a_cell(atoms,vect,num_atoms,closest_nn_contact,descriptor) * These contacts are printed to the output file. * *****************************************************************************/ -void check_nn_contacts(cell,details) - cell_type *cell; - detail_type *details; +void check_nn_contacts(cell_type *cell,detail_type *details) { int num_atoms; int i,j; @@ -250,9 +243,7 @@ void check_nn_contacts(cell,details) * see the file notes.outl for the representation of symmetric matrices. * *****************************************************************************/ -void build_distance_matrix(cell,details) - cell_type *cell; - detail_type *details; +void build_distance_matrix(cell_type *cell,detail_type *details) { int num_atoms; int i,j; @@ -338,8 +329,7 @@ is suspicious.\n",i+1,j+1,dist); * reciprocal lattice vectors * *****************************************************************************/ -void display_lattice_parms(cell) - cell_type *cell; +void display_lattice_parms(cell_type *cell) { static char first_call=0; @@ -452,15 +442,13 @@ typedef struct{ * it to a binary output file. * *****************************************************************************/ -void dump_distance_mats(cell,details) - cell_type *cell; - detail_type *details; +void dump_distance_mats(cell_type *cell,detail_type *details) { int num_atoms; int i,j,itab,jtab; point_type cell_dim[3]; point_type temp,vect; - char tempfilename[240]; + char tempfilename[512]; int matfile; int num_so_far; real dist,max_dist=-1; @@ -478,7 +466,6 @@ void dump_distance_mats(cell,details) cell_dim[i].z = cell->atoms[jtab].loc.z-cell->atoms[itab].loc.z; } - /* open the file */ sprintf(tempfilename,"%s.DMAT",details->filename); #ifndef _MSC_VER diff --git a/tightbind/driver.c b/tightbind/driver.c index 73d9f07d..2827dbc9 100644 --- a/tightbind/driver.c +++ b/tightbind/driver.c @@ -35,8 +35,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // For booleans #include "stdbool.h" -void set_details_defaults(details) - detail_type *details; +void set_details_defaults(detail_type *details) /* Set defaults struct to default options, ie off*/ { details->walsh_details.num_steps = 1; @@ -62,8 +61,7 @@ void set_details_defaults(details) details->line_width = 80; details->k_offset = K_OFFSET; } -void set_cell_defaults(cell) - cell_type *cell; +void set_cell_defaults(cell_type *cell) { cell->equiv_atoms = 0; cell->charge = -1000.0; diff --git a/tightbind/electrostat.c b/tightbind/electrostat.c index 57acc274..4c081001 100644 --- a/tightbind/electrostat.c +++ b/tightbind/electrostat.c @@ -52,8 +52,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * ****************************************************************************/ -int factorial(num) - int num; +int factorial(int num) { int i; real accum; @@ -67,8 +66,7 @@ int factorial(num) } /* this is the helper function for quicksorting the atomic energy level array */ -int compare_energies(a,b) - const void *a,*b; +int compare_energies(const void *a,const void *b) { return( (int)( *(real *)a - *(real *)b) ); } @@ -87,9 +85,7 @@ int compare_energies(a,b) * the "free atomic energy" used in extended Hueckel binding calculations. * ****************************************************************************/ -void free_atomic_energy(cell,energy,work_array) - cell_type *cell; - real *energy,*work_array; +void free_atomic_energy(cell_type *cell,real *energy,real *work_array) { atom_type *atom; int i; @@ -165,12 +161,7 @@ void free_atomic_energy(cell,energy,work_array) * the results are stored in 'accum which should be at least 'num_orbs long * ****************************************************************************/ -void AO_occupations(cell,num_orbs,OP_mat,orbital_lookup_table,accum) - cell_type *cell; - int num_orbs; - int *orbital_lookup_table; - real *OP_mat; - real *accum; +void AO_occupations(cell_type *cell,int num_orbs,real *OP_mat,int *orbital_lookup_table,real *accum) { atom_type *atom; static real *free_atom_occups=0; @@ -320,15 +311,9 @@ fprintf(stderr,"Atom %d p orbital occupation: %lg\n",i,accum[orbs_so_far]); * I've tried to keep the notation in the code similar. * ****************************************************************************/ -void eval_electrostatics(cell,num_orbs,eigenset,occupations,OP_mat,orbital_lookup_table, - electrostat_term,eHMO_term,total_E,accum,net_chgs) - cell_type *cell; - int num_orbs; - int *orbital_lookup_table; - real *occupations,*OP_mat; - eigenset_type eigenset; - real *electrostat_term,*eHMO_term,*total_E; - real *accum,*net_chgs; +void eval_electrostatics(cell_type *cell,int num_orbs,eigenset_type eigenset,real *occupations, + real *OP_mat,int *orbital_lookup_table, + real *electrostat_term,real *eHMO_term,real *total_E,real *accum,real *net_chgs) { static real *atomic_energy=0; atom_type *atomA,*atomB; diff --git a/tightbind/fileio.c b/tightbind/fileio.c index 7e065acf..980b5191 100644 --- a/tightbind/fileio.c +++ b/tightbind/fileio.c @@ -374,10 +374,7 @@ void write_atom_parms(detail_type *details,atom_type *atoms,int num_atoms, * EHT_PARM_FILE given above (or in the makefile) * *****************************************************************************/ -void fill_chg_it_parms(atoms,num_atoms,num_lines,infile) - atom_type *atoms; - int num_atoms,num_lines; - FILE *infile; +void fill_chg_it_parms(atom_type *atoms,int num_atoms,int num_lines,FILE *infile) { int i,j,num_read; char symb[10],instring[240]; @@ -428,11 +425,7 @@ void fill_chg_it_parms(atoms,num_atoms,num_lines,infile) * EHT_PARM_FILE given above (or in the makefile) * *****************************************************************************/ -void fill_atomic_parms(atoms,num_atoms,infile,parm_file_name) - atom_type *atoms; - int num_atoms; - FILE *infile; - char *parm_file_name; +void fill_atomic_parms(atom_type *atoms,int num_atoms,FILE *infile,char *parm_file_name) { char err_string[240],instring[240]; point_type saveloc; @@ -801,10 +794,7 @@ void fill_atomic_parms(atoms,num_atoms,infile,parm_file_name) * Action: This parses all the printing options that were given... * *****************************************************************************/ -void parse_printing_options(infile,details,cell) - FILE *infile; - detail_type *details; - cell_type *cell; +void parse_printing_options(FILE *infile,detail_type *details,cell_type *cell) { char instring[240]; char type_string[40]; @@ -1063,10 +1053,7 @@ void parse_printing_options(infile,details,cell) * Action: This parses the equivalent atom list given by the user * *****************************************************************************/ -void parse_equiv_atoms(infile,details,cell) - FILE *infile; - detail_type *details; - cell_type *cell; +void parse_equiv_atoms(FILE *infile,detail_type *details,cell_type *cell) { char instring[400]; int num_equiv; @@ -1134,10 +1121,7 @@ void parse_equiv_atoms(infile,details,cell) * the change I made in the notation used. * *****************************************************************************/ -void parse_muller_parms(infile,details,cell) - FILE *infile; - detail_type *details; - cell_type *cell; +void parse_muller_parms(FILE *infile,detail_type *details,cell_type *cell) { char instring[400],foostring[80]; int i,j; @@ -1347,10 +1331,7 @@ void parse_muller_parms(infile,details,cell) * Action: This parses all the charge iteration options that were given... * *****************************************************************************/ -void parse_charge_iteration(infile,details,cell) - FILE *infile; - detail_type *details; - cell_type *cell; +void parse_charge_iteration(FILE *infile,detail_type *details,cell_type *cell) { char instring[240]; char tempstring[240]; @@ -1474,15 +1455,8 @@ void parse_charge_iteration(infile,details,cell) * the information is read into the two structures 'cell and 'details * *****************************************************************************/ -void read_inputfile(cell,details,name,num_orbs,orbital_lookup_table,the_file, - parm_file_name) - cell_type *cell; - detail_type *details; - char *name; - int *num_orbs; - int **orbital_lookup_table; - FILE *the_file; - char *parm_file_name; +void read_inputfile(cell_type *cell,detail_type *details,char *name,int *num_orbs,int **orbital_lookup_table,FILE *the_file, + char *parm_file_name) { walsh_details_type *walsh; band_info_type *band_info; @@ -2206,7 +2180,7 @@ calculation.\n"); } else{ safe_strcpy(tempstring,(char *)strtok(0,",\n")); } - if( !tempstring || tempstring[0] == 0){ + if( tempstring[0] == 0){ done = 1; } else{ @@ -2462,7 +2436,7 @@ calculation.\n"); safe_strcpy(tempstring,(char *)strtok(0,",\n")); /* error checking */ - if( !tempstring || tempstring[0] == 0 ){ + if( tempstring[0] == 0 ){ fatal("Number of electrons unspecified for some fragments."); } @@ -2522,7 +2496,7 @@ calculation.\n"); safe_strcpy(tempstring,(char *)strtok(0,",\n")); /* error checking */ - if( !tempstring || tempstring[0] == 0 ){ + if( tempstring[0] == 0 ){ fatal("Number of electrons unspecified for some fragments."); } diff --git a/tightbind/genutil.c b/tightbind/genutil.c index 401a082d..c3533e23 100644 --- a/tightbind/genutil.c +++ b/tightbind/genutil.c @@ -118,8 +118,7 @@ void nonfatal_bug( char *errorstring, char *file, int line ) * * in case the job was queued, the error message is echoed to the status file */ -void fatal( errorstring ) - char *errorstring; +void fatal( char *errorstring ) { fprintf( stderr, "FATAL ERROR: %s.\nExecution Terminated.\n", errorstring ); @@ -139,8 +138,7 @@ void fatal( errorstring ) * * in case the job was queued, the error message is echoed to the status file */ -void error( errorstring ) - char *errorstring; +void error( char *errorstring ) { fprintf( stderr, "ERROR: %s.\n", errorstring ); @@ -163,8 +161,7 @@ void handle_sigint() /********* converts a string to all uppercase **********/ -void upcase(string) - char *string; +void upcase(char *string) { int i,len,diff; @@ -191,8 +188,7 @@ void upcase(string) * to make the use of strtok a little easier. * *****************************************************************************/ -char *safe_strcpy(str1,str2) - char *str1, *str2; +char *safe_strcpy(char *str1,char *str2) { if( !str1 ) fatal("safe_strcpy called with null str1"); if( !str2 ){ @@ -406,10 +402,7 @@ void map_orb_num_to_name(char *name,int orb_num,int *orbital_lookup_table, * if a given number is less than 'tol then a 0 is printed instead * *****************************************************************************/ -void debugmat( mat, num_row, num_col, tol ) - real *mat; - int num_row,num_col; - real tol; +void debugmat( real *mat, int num_row, int num_col, real tol ) { int i,j; int beg_col,end_col; @@ -915,11 +908,7 @@ int skipcomments(FILE *file,char *string,char toggle) * 'orbital_lookup_table. This does check for dummy atoms. * *****************************************************************************/ -void find_atoms_orbs(num_orbs,num_atoms,atom,orbital_lookup_table,begin,end) - int num_orbs,num_atoms; - int atom; - int *orbital_lookup_table; - int *begin,*end; +void find_atoms_orbs(int num_orbs,int num_atoms,int atom,int *orbital_lookup_table,int *begin,int *end) { char done; int next_real_atom; @@ -979,9 +968,7 @@ void find_atoms_orbs(num_orbs,num_atoms,atom,orbital_lookup_table,begin,end) * *****************************************************************************/ -int overlap_tab_from_vect(vect,cell) - point_type *vect; - cell_type *cell; +int overlap_tab_from_vect(point_type *vect,cell_type *cell) { int x,y,z; int L,M,N; @@ -1048,10 +1035,7 @@ int overlap_tab_from_vect(vect,cell) * user can do that will screw things up. * *****************************************************************************/ -void check_for_errors(cell,details,num_orbs) - cell_type *cell; - detail_type *details; - int num_orbs; +void check_for_errors(cell_type *cell,detail_type *details,int num_orbs) { int i,j; COOP_type *COOP_ptr,*COOP_ptr2; @@ -1178,10 +1162,7 @@ void check_for_errors(cell,details,num_orbs) * Action: Counts the number of orbitals and builds the orbital lookup table. * *****************************************************************************/ -void build_orbital_lookup_table(cell,num_orbs,orbital_lookup_table) - cell_type *cell; - int *num_orbs; - int **orbital_lookup_table; +void build_orbital_lookup_table(cell_type *cell,int *num_orbs,int **orbital_lookup_table) { int i; int num_so_far,atoms_so_far; @@ -1272,16 +1253,8 @@ void build_orbital_lookup_table(cell,num_orbs,orbital_lookup_table) * Action: Writes the MO output file. * *****************************************************************************/ -void print_MOs(details,num_orbs,eigenset,kpoint,unique_atoms,num_unique_atoms, - num_atoms,orbital_lookup_table) - detail_type *details; - int num_orbs; - eigenset_type eigenset; - int kpoint; - atom_type *unique_atoms; - int num_unique_atoms; - int num_atoms; - int *orbital_lookup_table; +void print_MOs(detail_type *details,int num_orbs,eigenset_type eigenset,int kpoint,atom_type *unique_atoms,int num_unique_atoms, + int num_atoms,int *orbital_lookup_table) { static char first_call=1; static int x_mirror_present,y_mirror_present,z_mirror_present; @@ -1474,8 +1447,7 @@ void print_MOs(details,num_orbs,eigenset,kpoint,unique_atoms,num_unique_atoms, * * *****************************************************************************/ -double d_sign(a,b) - double a,b; +double d_sign(double a,double b) { double x; @@ -1502,9 +1474,7 @@ double d_sign(a,b) * this deals with entries of the form "3-7", parsing this into 3,4,5,6,7. * ****************************************************************************/ -void parse_integer_string(string,values,num_values) - char *string; - int **values,*num_values; +void parse_integer_string(char *string,int **values,int *num_values) { int max_values; char local_string[400],num_string[80]; @@ -1568,10 +1538,7 @@ void parse_integer_string(string,values,num_values) * Action: Does a binary dump of the contents of 'mat into 'file * ****************************************************************************/ -void dump_hermetian_mat(file,mat,num_orbs) - int file; - real *mat; - int num_orbs; +void dump_hermetian_mat(int file,real *mat,int num_orbs) { write(file,(const char *)mat,num_orbs*num_orbs*sizeof(real)); } @@ -1594,11 +1561,7 @@ void dump_hermetian_mat(file,mat,num_orbs) * format Heinrich Roder likes. * ****************************************************************************/ -void dump_sparse_mat(file,mat,num_orbs,cut_off) - FILE *file; - real *mat; - int num_orbs; - real cut_off; +void dump_sparse_mat(FILE *file,real *mat,int num_orbs,real cut_off) { int i,j,itab,jtab; int num_non_zero,num_written; @@ -1693,8 +1656,7 @@ void dump_sparse_mat(file,mat,num_orbs,cut_off) * upon the specified charge. * ****************************************************************************/ -void charge_to_num_electrons(cell) - cell_type *cell; +void charge_to_num_electrons(cell_type *cell) { int i; real accum; diff --git a/tightbind/kpoints.c b/tightbind/kpoints.c index 09235c6d..abb9f23c 100644 --- a/tightbind/kpoints.c +++ b/tightbind/kpoints.c @@ -98,25 +98,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * ****************************************************************************/ -void loop_over_k_points(cell,details,overlapR,hamilR,overlapK,hamilK, - cmplx_hamil,cmplx_overlap, - eigenset,work1,work2,work3,cmplx_work, - properties,avg_prop_info, - num_orbs,orbital_lookup_table) - cell_type *cell; - detail_type *details; - hermetian_matrix_type overlapR,hamilR; - hermetian_matrix_type overlapK,hamilK; - complex *cmplx_hamil,*cmplx_overlap; - eigenset_type eigenset; - real *work1,*work2,*work3; - complex *cmplx_work; - prop_type *properties; - avg_prop_info_type *avg_prop_info; - int num_orbs; - int *orbital_lookup_table; +void loop_over_k_points(cell_type *cell,detail_type *details, + hermetian_matrix_type overlapR,hermetian_matrix_type hamilR, + hermetian_matrix_type overlapK,hermetian_matrix_type hamilK, + complex *cmplx_hamil,complex *cmplx_overlap, + eigenset_type eigenset,real *work1,real *work2,real *work3, + complex *cmplx_work, + prop_type *properties,avg_prop_info_type *avg_prop_info, + int num_orbs,int *orbital_lookup_table) { - static char tempfilename[240]; + static char tempfilename[512]; static char *label=0; static FILE *sparse_OVfile,*sparse_HAMfile; k_point_type *kpoint; diff --git a/tightbind/main.c b/tightbind/main.c index 81d3e78a..137b0930 100644 --- a/tightbind/main.c +++ b/tightbind/main.c @@ -59,9 +59,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. FILE *COHP_file; const char greetings[]="Welcome to the 10th Anniversary edition of YAeHMOP!\n"; -void main(argc, argv) - int argc; - char **argv; +int main(int argc, char **argv) { FILE *temp_file; char file_name[500]; diff --git a/tightbind/matrices.c b/tightbind/matrices.c index 012e1d70..480e5d03 100644 --- a/tightbind/matrices.c +++ b/tightbind/matrices.c @@ -53,10 +53,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * Action: zeroes all the elements of 'mat which are smaller than 'value * ****************************************************************************/ -void sparsify_hermetian_matrix(value,mat,num_orbs) - real value; - hermetian_matrix_type mat; - int num_orbs; +void sparsify_hermetian_matrix(real value,hermetian_matrix_type mat,int num_orbs) { int i,j,itab,jtab; int num_zeroed; @@ -106,10 +103,7 @@ void sparsify_hermetian_matrix(value,mat,num_orbs) * which are smaller than 'value * ****************************************************************************/ -void sparsify_matrix(value,mat_R,mat_I,num_orbs) - real value; - real *mat_R,*mat_I; - int num_orbs; +void sparsify_matrix(real value,real *mat_R,real *mat_I,int num_orbs) { int i,j,itab,jtab; int num_zeroed; diff --git a/tightbind/memory.c b/tightbind/memory.c index 75e58373..658f1c21 100644 --- a/tightbind/memory.c +++ b/tightbind/memory.c @@ -214,24 +214,16 @@ int *my_realloc(int *ptr, int size) * stored in one triangle and the imaginary in the other. * *****************************************************************************/ -void allocate_matrices(cell,details,H_R,S_R, - H_K,S_K,cmplx_hamil,cmplx_overlap,eigenset,work1,work2, - work3,cmplx_work,properties,avg_prop_info,num_orbs,tot_overlaps, - orbital_lookup_table,orbital_ordering) - cell_type *cell; - detail_type *details; - hermetian_matrix_type *H_R,*S_R; - hermetian_matrix_type *H_K,*S_K; - complex **cmplx_hamil,**cmplx_overlap; - eigenset_type *eigenset; - real **work1,**work2,**work3; - complex **cmplx_work; - prop_type *properties; - avg_prop_info_type **avg_prop_info; - int num_orbs; - int *tot_overlaps; - int *orbital_lookup_table; - K_orb_ptr_type **orbital_ordering; +void allocate_matrices(cell_type *cell,detail_type *details, + hermetian_matrix_type *H_R,hermetian_matrix_type *S_R, + hermetian_matrix_type *H_K,hermetian_matrix_type *S_K, + complex **cmplx_hamil,complex **cmplx_overlap, + eigenset_type *eigenset, + real **work1,real **work2, + real **work3,complex **cmplx_work, + prop_type *properties,avg_prop_info_type **avg_prop_info, + int num_orbs,int *tot_overlaps, + int *orbital_lookup_table,K_orb_ptr_type **orbital_ordering) { FMO_frag_type *FMO_frag; diff --git a/tightbind/mod_mulliken.c b/tightbind/mod_mulliken.c index 81528f57..03c2f50f 100644 --- a/tightbind/mod_mulliken.c +++ b/tightbind/mod_mulliken.c @@ -79,14 +79,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * be filled with the occupation numbers of the various orbitals. * ****************************************************************************/ -void modified_mulliken(cell,eigenset,overlap,num_orbs, - occupations,orbital_lookup_table,OP_matrix, - mod_OP_matrix,net_chgs,accum) - cell_type *cell; - eigenset_type eigenset; - hermetian_matrix_type overlap; - int num_orbs,*orbital_lookup_table; - real *occupations,*OP_matrix,*mod_OP_matrix,*accum,*net_chgs; +void modified_mulliken(cell_type *cell,eigenset_type eigenset,hermetian_matrix_type overlap,int num_orbs, + real *occupations,int *orbital_lookup_table,real *OP_matrix, + real *mod_OP_matrix,real *net_chgs,real *accum) { int num_atoms; int i,j,k; diff --git a/tightbind/mov.c b/tightbind/mov.c index 49db9d86..5a961683 100644 --- a/tightbind/mov.c +++ b/tightbind/mov.c @@ -65,11 +65,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * comments will follow the clue when I get one * ********************************************************************************/ -void mov(sigma,pi,delta,phi,which1,which2,dist,q_num1,q_num2, - l1,l2,atoms) - real *sigma,*pi,*delta,*phi,dist; - int which1,which2,q_num1,q_num2,l1,l2; - atom_type *atoms; +void mov(real *sigma,real *pi,real *delta,real *phi,int which1,int which2,real dist,int q_num1,int q_num2, + int l1,int l2,atom_type *atoms) { int i,j,num_zeta1,num_zeta2; real coeff_1,coeff_2,sk1,sk2,r; diff --git a/tightbind/muller.c b/tightbind/muller.c index 6a90c992..8e82e86b 100644 --- a/tightbind/muller.c +++ b/tightbind/muller.c @@ -257,14 +257,8 @@ void calc_muller_parms(atom_type *atom, real s_occup,real p_occup,real d_occup, * atomic Hii's and zetas using Muller's iteration technique * ****************************************************************************/ -void update_muller_it_parms(details,cell,AO_occups,converged,num_orbs, - orbital_lookup_table) - detail_type *details; - cell_type *cell; - real *AO_occups; - int *converged; - int num_orbs; - int *orbital_lookup_table; +void update_muller_it_parms(detail_type *details,cell_type *cell,real *AO_occups,int *converged,int num_orbs, + int *orbital_lookup_table) { static int num_its = 0; static char *atoms_done=0; diff --git a/tightbind/mulliken.c b/tightbind/mulliken.c index a2d7d6b7..95daf651 100644 --- a/tightbind/mulliken.c +++ b/tightbind/mulliken.c @@ -60,12 +60,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * specified orbitals. * ****************************************************************************/ -void calc_occupations(details,num_electrons,num_orbs,occupations,eigenset) - detail_type *details; - real num_electrons; - int num_orbs; - real *occupations; - eigenset_type eigenset; +void calc_occupations(detail_type *details,real num_electrons,int num_orbs,real *occupations,eigenset_type eigenset) { int i,begin_degen,end_degen,num_degen_levels,last_occup; real num_degen_electrons; @@ -148,10 +143,7 @@ void calc_occupations(details,num_electrons,num_orbs,occupations,eigenset) * num_atoms * num_atoms * ****************************************************************************/ -void reduced_mulliken(num_atoms,num_orbs,orbital_lookup_table,OP_matrix,ROP_matrix) - int num_atoms,num_orbs,*orbital_lookup_table; - real *OP_matrix; - real *ROP_matrix; +void reduced_mulliken(int num_atoms,int num_orbs,int *orbital_lookup_table,real *OP_matrix,real *ROP_matrix) { int i,j,k,l; int ktab; @@ -222,11 +214,7 @@ void reduced_mulliken(num_atoms,num_orbs,orbital_lookup_table,OP_matrix,ROP_matr * details->num_FMO_frags * details->num_FMO_frags * ****************************************************************************/ -void FMO_reduced_mulliken(details,num_atoms,num_orbs,OP_matrix,ROP_matrix) - detail_type *details; - int num_atoms,num_orbs; - real *OP_matrix; - real *ROP_matrix; +void FMO_reduced_mulliken(detail_type *details,int num_atoms,int num_orbs,real *OP_matrix,real *ROP_matrix) { FMO_frag_type *FMO_frag1,*FMO_frag2; int frag1,frag2; @@ -356,13 +344,8 @@ void FMO_reduced_mulliken(details,num_atoms,num_orbs,OP_matrix,ROP_matrix) * be filled with the occupation numbers of the various orbitals. * ****************************************************************************/ -void eval_mulliken(cell,eigenset,overlap,num_orbs, - occupations,orbital_lookup_table,OP_matrix,net_chgs,accum) - cell_type *cell; - eigenset_type eigenset; - hermetian_matrix_type overlap; - int num_orbs,*orbital_lookup_table; - real *occupations,*OP_matrix,*accum,*net_chgs; +void eval_mulliken(cell_type *cell,eigenset_type eigenset,hermetian_matrix_type overlap,int num_orbs, + real *occupations,int *orbital_lookup_table,real *OP_matrix,real *net_chgs,real *accum) { int num_atoms; int i,j,k; diff --git a/tightbind/new3_fileio.c b/tightbind/new3_fileio.c index 83303697..50b83248 100644 --- a/tightbind/new3_fileio.c +++ b/tightbind/new3_fileio.c @@ -55,11 +55,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * Action: reads all the data out of the file 'infile * *****************************************************************************/ -void read_NEW3file(cell,details,infile,parm_file_name) - cell_type *cell; - detail_type *details; - FILE *infile; - char *parm_file_name; +void read_NEW3file(cell_type *cell,detail_type *details,FILE *infile,char *parm_file_name) { char err_string[240]; char instring[90]; diff --git a/tightbind/postprocess.c b/tightbind/postprocess.c index 8a3521ef..06041d89 100644 --- a/tightbind/postprocess.c +++ b/tightbind/postprocess.c @@ -63,23 +63,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * Returns: none * ****************************************************************************/ -void postprocess_FMO(cell,details,overlapR,hamilR,overlapK,hamilK, - cmplx_hamil,cmplx_overlap, - eigenset,work1,work2,work3,cmplx_work, - properties,avg_prop_info, - num_orbs,orbital_lookup_table) - cell_type *cell; - detail_type *details; - hermetian_matrix_type overlapR,hamilR; - hermetian_matrix_type overlapK,hamilK; - complex *cmplx_hamil,*cmplx_overlap; - eigenset_type eigenset; - real *work1,*work2,*work3; - complex *cmplx_work; - prop_type *properties; - avg_prop_info_type *avg_prop_info; - int num_orbs; - int *orbital_lookup_table; +void postprocess_FMO(cell_type *cell,detail_type *details,hermetian_matrix_type overlapR,hermetian_matrix_type hamilR, + hermetian_matrix_type overlapK,hermetian_matrix_type hamilK, + complex *cmplx_hamil,complex *cmplx_overlap, + eigenset_type eigenset,real *work1,real *work2,real *work3,complex *cmplx_work, + prop_type *properties,avg_prop_info_type *avg_prop_info, + int num_orbs,int *orbital_lookup_table) { real *occupations; real *chg_mat; @@ -264,27 +253,16 @@ void postprocess_FMO(cell,details,overlapR,hamilR,overlapK,hamilK, * Returns: none * ****************************************************************************/ -void postprocess_FCO(cell,details,overlapR,hamilR,overlapK,hamilK, - cmplx_hamil,cmplx_overlap, - eigenset,work1,work2,work3,cmplx_work, - properties,avg_prop_info, - num_orbs,orbital_lookup_table) - cell_type *cell; - detail_type *details; - hermetian_matrix_type overlapR,hamilR; - hermetian_matrix_type overlapK,hamilK; - complex *cmplx_hamil,*cmplx_overlap; - eigenset_type eigenset; - real *work1,*work2,*work3; - complex *cmplx_work; - prop_type *properties; - avg_prop_info_type *avg_prop_info; - int num_orbs; - int *orbital_lookup_table; +void postprocess_FCO(cell_type *cell,detail_type *details,hermetian_matrix_type overlapR,hermetian_matrix_type hamilR, + hermetian_matrix_type overlapK,hermetian_matrix_type hamilK, + complex *cmplx_hamil,complex *cmplx_overlap, + eigenset_type eigenset,real *work1,real *work2,real *work3,complex *cmplx_work, + prop_type *properties,avg_prop_info_type *avg_prop_info, + int num_orbs,int *orbital_lookup_table) { static int FCO_file=0; - char FCO_filename[240]; + char FCO_filename[512]; real tot_K_weight; real *occupations; @@ -511,23 +489,13 @@ void postprocess_FCO(cell,details,overlapR,hamilR,overlapK,hamilK, * and easier to deal with. * ****************************************************************************/ -void postprocess_results(cell,details,overlapR,hamilR,overlapK,hamilK, - cmplx_hamil,cmplx_overlap, - eigenset,work1,work2,work3,cmplx_work, - properties,avg_prop_info, - num_orbs,orbital_lookup_table) - cell_type *cell; - detail_type *details; - hermetian_matrix_type overlapR,hamilR; - hermetian_matrix_type overlapK,hamilK; - complex *cmplx_hamil,*cmplx_overlap; - eigenset_type eigenset; - real *work1,*work2,*work3; - complex *cmplx_work; - prop_type *properties; - avg_prop_info_type *avg_prop_info; - int num_orbs; - int *orbital_lookup_table; +void postprocess_results(cell_type *cell,detail_type *details,hermetian_matrix_type overlapR,hermetian_matrix_type hamilR, + hermetian_matrix_type overlapK,hermetian_matrix_type hamilK, + complex *cmplx_hamil,complex *cmplx_overlap, + eigenset_type eigenset, + real *work1,real *work2,real *work3,complex *cmplx_work, + prop_type *properties,avg_prop_info_type *avg_prop_info, + int num_orbs,int *orbital_lookup_table) { real *occupations; diff --git a/tightbind/princ_axes.c b/tightbind/princ_axes.c index 935c7724..3d75e53f 100644 --- a/tightbind/princ_axes.c +++ b/tightbind/princ_axes.c @@ -68,11 +68,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * to translate the atoms to center of mass coordinates first. * *****************************************************************************/ -void find_princ_axes(atoms,locs,princ_axes,moments,num_atoms) - atom_type *atoms; - point_type *locs; - real moments[3],princ_axes[3][3]; - int num_atoms; +void find_princ_axes(atom_type *atoms,point_type *locs,real princ_axes[3][3],real moments[3],int num_atoms) { int i,j; atom_type *atom; diff --git a/tightbind/symmetry.c b/tightbind/symmetry.c index 3975654e..51530778 100644 --- a/tightbind/symmetry.c +++ b/tightbind/symmetry.c @@ -67,11 +67,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * this symmetry op will be printed out as well. * *****************************************************************************/ -void name_sym_element(elem,the_file,num_atoms,show_equiv) - sym_op_type *elem; - FILE *the_file; - int num_atoms; - int show_equiv; +void name_sym_element(sym_op_type *elem,FILE *the_file,int num_atoms,int show_equiv) { int i; @@ -130,13 +126,7 @@ void name_sym_element(elem,the_file,num_atoms,show_equiv) * This also constructs the list of equivalent atoms: 'equiv_atoms * *****************************************************************************/ -void compare_molecules(atoms,locs1,locs2,num_atoms,equiv_atoms,present,symm_tol) - atom_type *atoms; - point_type *locs1,*locs2; - int num_atoms; - int *equiv_atoms; - char *present; - real symm_tol; +void compare_molecules(atom_type *atoms,point_type *locs1,point_type *locs2,int num_atoms,int *equiv_atoms,char *present,real symm_tol) { int i,j; char found; @@ -316,6 +306,8 @@ void construct_rotn_mats(enum possible_axis axis,real angle, axis_v->z = 1.0; break; + default: + break; } } @@ -335,9 +327,7 @@ void construct_rotn_mats(enum possible_axis axis,real angle, * is only called once so who cares? * *****************************************************************************/ -void gen_sym_ops(the_ops,num_ops) - sym_op_type **the_ops; - int *num_ops; +void gen_sym_ops(sym_op_type **the_ops,int *num_ops) { sym_op_type *op_ptr; enum possible_sym_op op; @@ -382,7 +372,7 @@ void gen_sym_ops(the_ops,num_ops) ******/ op_ptr->next = make_new_sym_op(); op_ptr = op_ptr->next; - *num_ops++; + ++(*num_ops); } break; case Improper_Rotation: @@ -472,6 +462,8 @@ void gen_sym_ops(the_ops,num_ops) op_ptr->axis.z = 1.0; break; + default: + break; } op_ptr->angle = angle; op_ptr->order = i; @@ -482,7 +474,7 @@ void gen_sym_ops(the_ops,num_ops) ******/ op_ptr->next = make_new_sym_op(); op_ptr = op_ptr->next; - *num_ops++; + ++(*num_ops); } break; case Mirror: @@ -513,10 +505,14 @@ void gen_sym_ops(the_ops,num_ops) op_ptr->axis.z = 1.0; break; + default: + break; } op_ptr->next = make_new_sym_op(); op_ptr = op_ptr->next; - *num_ops++; + ++(*num_ops); + break; + default: break; } } @@ -537,7 +533,7 @@ void gen_sym_ops(the_ops,num_ops) *********/ op_ptr->next = make_new_sym_op(); op_ptr = op_ptr->next; - *num_ops++; + ++(*num_ops); } } @@ -962,9 +958,7 @@ void find_off_axis_sym_ops(detail_type *details,cell_type *cell, * variable sym_ops_present * *****************************************************************************/ -void find_sym_ops(details,cell) - detail_type *details; - cell_type *cell; +void find_sym_ops(detail_type *details,cell_type *cell) { int i,j,itab,jtab; static point_type *COM_locs,*new_locs; @@ -1257,9 +1251,7 @@ void find_sym_ops(details,cell) * from the list, and any element which appears will never be found. * *****************************************************************************/ -void find_walsh_sym_ops(cell,details) - cell_type *cell; - detail_type *details; +void find_walsh_sym_ops(cell_type *cell,detail_type *details) { int i,j; point_type *COM_locs,*new_locs; @@ -1500,13 +1492,8 @@ void find_walsh_sym_ops(cell,details) * with them. * *****************************************************************************/ -void find_MO_symmetries(num_orbs,details,cell,eigenset,overlap,orbital_lookup_table) - int num_orbs; - detail_type *details; - cell_type *cell; - eigenset_type eigenset; - hermetian_matrix_type overlap; - int *orbital_lookup_table; +void find_MO_symmetries(int num_orbs,detail_type *details,cell_type *cell,eigenset_type eigenset, + hermetian_matrix_type overlap,int *orbital_lookup_table) { static real *AO_coeffs=0; static real *norm_fact=0; diff --git a/tightbind/test_driver.c b/tightbind/test_driver.c index 079f93c1..2ce96336 100644 --- a/tightbind/test_driver.c +++ b/tightbind/test_driver.c @@ -36,7 +36,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "stdbool.h" -void main(int argc, char **argv){ +int main(int argc, char **argv){ char err_string[240]; int i, j; FILE *nullfile = fopen("nul","w"); diff --git a/tightbind/transforms.c b/tightbind/transforms.c index f46bd87f..538e839f 100644 --- a/tightbind/transforms.c +++ b/tightbind/transforms.c @@ -55,8 +55,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * the resulting difference is returned in 'diff. * *****************************************************************************/ -void vector_diff(vect1,vect2,diff) - point_type *vect1,*vect2,*diff; +void vector_diff(point_type *vect1,point_type *vect2,point_type *diff) { diff->x = vect1->x-vect2->x; diff->y = vect1->y-vect2->y; @@ -74,8 +73,7 @@ void vector_diff(vect1,vect2,diff) * Action: This normalizes vector 'vect and returns the result in 'norm_vect * *****************************************************************************/ -void normalize_vector(vect,norm_vect) - point_type *vect,*norm_vect; +void normalize_vector(point_type *vect,point_type *norm_vect) { real norm_fact; @@ -99,8 +97,7 @@ void normalize_vector(vect,norm_vect) * Action: Returns the dot product of 'vect1 and 'vect2 * *****************************************************************************/ -real dot_prod(vect1,vect2) - point_type *vect1,*vect2; +real dot_prod(point_type *vect1,point_type *vect2) { return(vect1->x*vect2->x + vect1->y*vect2->y + vect1->z*vect2->z); } @@ -137,8 +134,7 @@ void scale_vector(point_type *vect,real scalar) * vector in 'result * *****************************************************************************/ -void cross_prod(vect1,vect2,result) - point_type *vect1,*vect2,*result; +void cross_prod(point_type *vect1,point_type *vect2,point_type *result) { result->x = vect1->y*vect2->z - vect1->z*vect2->y; @@ -189,9 +185,7 @@ void mult_matrices(real *mat1,real *mat2,real *result,int dim) * Action: Translates all the atomic positions in 'atom_locs by 'pos * *****************************************************************************/ -void translate_atoms(atom_locs,pos,num_atoms) - point_type *atom_locs,pos; - int num_atoms; +void translate_atoms(point_type *atom_locs,point_type pos,int num_atoms) { int i; @@ -223,10 +217,7 @@ void translate_atoms(atom_locs,pos,num_atoms) * fill in the values for the homogeneous variables. * *****************************************************************************/ -void transform_atomic_locs(atom_locs,t_mat,num_atoms) - point_type *atom_locs; - real t_mat[T_MAT_DIM][T_MAT_DIM]; - int num_atoms; +void transform_atomic_locs(point_type *atom_locs,real t_mat[T_MAT_DIM][T_MAT_DIM],int num_atoms) { int atom,i,j; static real loc[T_MAT_DIM],new_loc[T_MAT_DIM]; @@ -317,10 +308,7 @@ void transform_one_point(point_type *the_point,real t_mat[T_MAT_DIM][T_MAT_DIM]) * use for the eigenvectors of a matrix. * *****************************************************************************/ -void transform_3x3_transpose(atom_locs,t_mat,num_atoms) - point_type *atom_locs; - real t_mat[3][3]; - int num_atoms; +void transform_3x3_transpose(point_type *atom_locs,real t_mat[3][3],int num_atoms) { int atom,i,j; static real loc[3],new_loc[3]; @@ -366,8 +354,7 @@ void transform_3x3_transpose(atom_locs,t_mat,num_atoms) * fill in the values for the homogeneous variables. * *****************************************************************************/ -void transform_p_orbs(coeffs,t_mat) - real *coeffs,t_mat[T_MAT_DIM][T_MAT_DIM]; +void transform_p_orbs(real *coeffs,real t_mat[T_MAT_DIM][T_MAT_DIM]) { static real result[T_MAT_DIM]; int i,j; @@ -401,8 +388,7 @@ void transform_p_orbs(coeffs,t_mat) * fill in the values for the homogeneous variables. * *****************************************************************************/ -void transform_d_orbs(coeffs,d_t_mat) - real *coeffs,d_t_mat[D_T_MAT_DIM][D_T_MAT_DIM]; +void transform_d_orbs(real *coeffs,real d_t_mat[D_T_MAT_DIM][D_T_MAT_DIM]) { static real result[D_T_MAT_DIM]; int i,j; @@ -434,10 +420,7 @@ void transform_d_orbs(coeffs,d_t_mat) * the matrices in 'sym_op. * *****************************************************************************/ -void transform_orbitals(atom,coeffs,sym_op) - atom_type *atom; - real *coeffs; - sym_op_type *sym_op; +void transform_orbitals(atom_type *atom,real *coeffs,sym_op_type *sym_op) { real *coeff_tab; @@ -480,11 +463,7 @@ void transform_orbitals(atom,coeffs,sym_op) * use for the eigenvectors of a matrix. * *****************************************************************************/ -void full_transform(atoms,COM,t_mat,num_atoms) - atom_type *atoms; - point_type COM; - real t_mat[3][3]; - int num_atoms; +void full_transform(atom_type *atoms,point_type COM,real t_mat[3][3],int num_atoms) { int atom,i,j; static real loc[3],new_loc[3]; @@ -535,10 +514,7 @@ void full_transform(atoms,COM,t_mat,num_atoms) * fill in the values for the homogeneous variables. * *****************************************************************************/ -void transform_atoms(atoms,t_mat,num_atoms) - atom_type *atoms; - real t_mat[T_MAT_DIM][T_MAT_DIM]; - int num_atoms; +void transform_atoms(atom_type *atoms,real t_mat[T_MAT_DIM][T_MAT_DIM],int num_atoms) { int atom,i,j; static real loc[T_MAT_DIM],new_loc[T_MAT_DIM]; diff --git a/tightbind/walsh.c b/tightbind/walsh.c index b50ac792..a0302e2f 100644 --- a/tightbind/walsh.c +++ b/tightbind/walsh.c @@ -64,10 +64,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * NOTE: I'll give you a fence post problem.... * *****************************************************************************/ -void auto_walsh(values,num_steps,begin,end) - real *values; - int num_steps; - real begin,end; +void auto_walsh(real *values,int num_steps,real begin,real end) { int i; real tot_dist,step,cur_val; @@ -382,16 +379,9 @@ void walsh_update(cell_type *cell,detail_type *details,int step,char printing) * puts the relevant information in the walsh output file. * *****************************************************************************/ -void walsh_output(details,cell,num_orbs,eigenset,overlap,hamil, - properties,orbital_lookup_table,step) - detail_type *details; - cell_type *cell; - int num_orbs; - eigenset_type eigenset; - hermetian_matrix_type overlap,hamil; - prop_type properties; - int *orbital_lookup_table; - int step; +void walsh_output(detail_type *details,cell_type *cell,int num_orbs,eigenset_type eigenset, + hermetian_matrix_type overlap,hermetian_matrix_type hamil, + prop_type properties,int *orbital_lookup_table,int step) { static char first_call=1; int i;