mirror of
https://github.com/arcan1s/moldyn.git
synced 2025-07-15 14:55:50 +00:00
start moving to another architecture
This commit is contained in:
arcan1s
21
mathmech/radf/src/CMakeLists.txt
Normal file
21
mathmech/radf/src/CMakeLists.txt
Normal file
@ -0,0 +1,21 @@
|
||||
# set files
|
||||
file (GLOB SOURCES *.c)
|
||||
file (GLOB HEADERS *.h)
|
||||
|
||||
# set library
|
||||
if (CMAKE_COMPILER_IS_GNUCXX)
|
||||
set (ADDITIONAL_LIB m)
|
||||
else ()
|
||||
set (ADDITIONAL_LIB)
|
||||
endif ()
|
||||
|
||||
# message
|
||||
message (STATUS "${PROJECT} SOURCES: ${SOURCES}")
|
||||
message (STATUS "${PROJECT} HEADERS: ${HEADERS}")
|
||||
|
||||
# link libraries and compile
|
||||
add_executable (${MM_PREFIX}${PROJECT} ${SOURCES} ${HEADERS})
|
||||
target_link_libraries (${MM_PREFIX}${PROJECT} ${ADDITIONAL_LIB} ${LIBRARIES})
|
||||
|
||||
# install properties
|
||||
install (TARGETS ${MM_PREFIX}${PROJECT} DESTINATION bin)
|
||||
211
mathmech/radf/src/add_main.c
Normal file
211
mathmech/radf/src/add_main.c
Normal file
@ -0,0 +1,211 @@
|
||||
/**
|
||||
* @file
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include <mathmech/messages.h>
|
||||
|
||||
|
||||
/**
|
||||
* @fn error_checking
|
||||
*/
|
||||
int error_checking (const float *cell, const int from, const char *input,
|
||||
const int num_needed_at, const int *needed_at,
|
||||
const char *output, const int to)
|
||||
/**
|
||||
* @brief function that checks errors in input variables
|
||||
* @code
|
||||
* error_checking (cell, from, input, num_needed_at, needed_at, output, to);
|
||||
* @endcode
|
||||
*
|
||||
* @param cell massive of cell size
|
||||
* @param from first trajectory step
|
||||
* @param input input file name
|
||||
* @param num_needed_at number of needed atom types
|
||||
* @param needed_at massive of number of needed atom types
|
||||
* @param output output file name
|
||||
* @param to last trajectory step
|
||||
*
|
||||
* @return 11 - error in 'cell'
|
||||
* @return 12 - error in 'input'
|
||||
* @return 13 - error in 'output'
|
||||
* @return 14 - error in 'from' or 'to'
|
||||
* @return 15 - error in 'num_needed_at'
|
||||
* @return 16 - error in 'needed_at'
|
||||
* @return 0 - exit without errors
|
||||
*/
|
||||
{
|
||||
if ((cell[0] == 0.0) || (cell[1] == 0.0) || (cell[2] == 0.0))
|
||||
return 11;
|
||||
if (input[0] == '#')
|
||||
return 12;
|
||||
if (output[0] == '#')
|
||||
return 13;
|
||||
if ((from == -1) || (to == -1))
|
||||
return 14;
|
||||
if ((num_needed_at != 2) && (num_needed_at != 6))
|
||||
return 15;
|
||||
if (num_needed_at == 6)
|
||||
if ((needed_at[0] == needed_at[1]) ||
|
||||
(needed_at[0] == needed_at[2]) ||
|
||||
(needed_at[1] == needed_at[2]) ||
|
||||
(needed_at[3] == needed_at[4]) ||
|
||||
(needed_at[3] == needed_at[5]) ||
|
||||
(needed_at[4] == needed_at[5]))
|
||||
return 16;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @fn print_message
|
||||
*/
|
||||
int print_message (const int quiet, FILE *std_output, const int log, FILE *f_log,
|
||||
const int mode, const char *str)
|
||||
/**
|
||||
* @brief function that prints message in log and stdout
|
||||
* @code
|
||||
* print_message (quiet, stdout, log, f_log, 0, str);
|
||||
* @endcode
|
||||
*
|
||||
* @param quiet status of quiet-mode
|
||||
* @param std_output stdout
|
||||
* @param log status of log-mode
|
||||
* @param f_log log file
|
||||
* @param mode number of message in "messages.c"
|
||||
* @param str additional text in message
|
||||
*
|
||||
* @return 0 - exit without errors
|
||||
*/
|
||||
{
|
||||
if ((quiet != 1) && (std_output != stderr))
|
||||
message (0, mode, str, std_output);
|
||||
if (log == 1)
|
||||
message (1, mode, str, f_log);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @fn printing_head
|
||||
*/
|
||||
int printing_head (const char *output, const int log, const int quiet, const int matrix,
|
||||
const char *input, const int from, const int to, const float *cell,
|
||||
const int mode, const double r_min, const double r_max,
|
||||
const double r_step, const double ang_min, const double ang_max,
|
||||
const double ang_step, const int *needed_at)
|
||||
/**
|
||||
* @brief function that prints header in output file
|
||||
* @code
|
||||
* printing_head (output, log, quiet, matrix, input, from, to, cell, mode, r_min,
|
||||
* r_max, r_step, ang_min, ang_max, ang_step, needed_at);
|
||||
* @endcode
|
||||
*
|
||||
* @param output output file nams
|
||||
* @param log status of log-mode
|
||||
* @param quiet status of quiet-mode
|
||||
* @param matrix status of matrix-mode
|
||||
* @param input mask of trajectory files
|
||||
* @param from first trajectory step
|
||||
* @param to last trajectory step
|
||||
* @param cell massive of cell size
|
||||
* @param mode 0 - if RDF, 1 - if RDF for center mass, 2 - if RADF
|
||||
* @param r_max maximal radius
|
||||
* @param r_min minimal radius
|
||||
* @param r_step radius step
|
||||
* @param ang_max maximal angle for RADF
|
||||
* @param ang_min minimal angle for RADF
|
||||
* @param ang_step anlge step for RADF
|
||||
* @param needed_at massive of number of needed atom types
|
||||
*
|
||||
* @return 0 - exit without errors
|
||||
*/
|
||||
{
|
||||
FILE *f_out;
|
||||
|
||||
f_out = fopen (output, "w");
|
||||
fprintf (f_out, "radf ::: V.1.1.1\n\n");
|
||||
fprintf (f_out, "CONFIGURATION\n");
|
||||
|
||||
fprintf (f_out, "LOG=%i\nQUIET=%i\nMATRIX=%i\n", log, quiet, matrix);
|
||||
fprintf (f_out, "MASK=%s\nFIRST=%i\nLAST=%i\n", input, from, to);
|
||||
fprintf (f_out, "CELL=%.4f,%.4f,%.4f\n", cell[0], cell[1], cell[2]);
|
||||
fprintf (f_out, "MODE=%i\n", mode);
|
||||
fprintf (f_out, "R_MIN=%.3f\nR_MAX=%.3f\nR_STEP=%.3f\n", r_min, r_max, r_step);
|
||||
switch (mode)
|
||||
{
|
||||
case 0:
|
||||
fprintf (f_out, "ATOM=%i-%i\n", needed_at[0], needed_at[1]);
|
||||
break;
|
||||
case 1:
|
||||
fprintf (f_out, "ATOM=%i,%i,%i-%i,%i,%i\n", needed_at[0], needed_at[1],
|
||||
needed_at[2], needed_at[3], needed_at[4], needed_at[5]);
|
||||
break;
|
||||
case 2:
|
||||
fprintf (f_out, "ANG_MIN=%.2f\nANG_MAX=%.2f\nANG_STEP=%.2f\n\
|
||||
ATOM=%i,%i,%i-%i,%i,%i\n",ang_min, ang_max, ang_step, needed_at[0], needed_at[1],
|
||||
needed_at[2], needed_at[3], needed_at[4], needed_at[5]);
|
||||
break;
|
||||
}
|
||||
|
||||
fprintf (f_out, "END\n\n");
|
||||
fclose (f_out);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @fn set_defaults
|
||||
*/
|
||||
int set_defaults (float *ang_max, float *ang_min, float *ang_step, float *cell,
|
||||
int *from, char *input, int *log, int *matrix, float *r_max,
|
||||
float *r_min, float *r_step, char *output, int *to, int *quiet)
|
||||
/**
|
||||
* @brief function that sets default values of variables
|
||||
* @code
|
||||
* set_defaults (&ang_max, &ang_min, &ang_step, cell, &from, input, &log, &r_max,
|
||||
* &r_min, &r_step, output, &to, &quiet);
|
||||
* @endcode
|
||||
*
|
||||
* @param ang_max maximal angle for RADF
|
||||
* @param ang_min minimal angle for RADF
|
||||
* @param ang_step angle step
|
||||
* @param cell massive of cell size
|
||||
* @param from first trajectory step
|
||||
* @param input mask of trajectory files
|
||||
* @param log status of log-mode
|
||||
* @param matrix status of matrix-mode
|
||||
* @param r_max maximal radius
|
||||
* @param r_min minimal radius
|
||||
* @param r_step radius step
|
||||
* @param output output file name
|
||||
* @param to last trajectory step
|
||||
* @param quiet status of quiet-mode
|
||||
*
|
||||
* @return 0 - exit without errors
|
||||
*/
|
||||
{
|
||||
int i;
|
||||
|
||||
*ang_max = 90.0;
|
||||
*ang_min = 0.0;
|
||||
*ang_step = 0.0;
|
||||
for (i=0; i<3; i++)
|
||||
cell[i] = 0.0;
|
||||
*from = -1;
|
||||
input[0] = '#';
|
||||
*log = 0;
|
||||
*matrix = 0;
|
||||
*r_max = 15.0;
|
||||
*r_min = 2.0;
|
||||
*r_step = 0.2;
|
||||
output[0] = '#';
|
||||
*to = -1;
|
||||
*quiet = 0;
|
||||
|
||||
return 0;
|
||||
}
|
||||
31
mathmech/radf/src/add_main.h
Normal file
31
mathmech/radf/src/add_main.h
Normal file
@ -0,0 +1,31 @@
|
||||
/**
|
||||
* @file
|
||||
*/
|
||||
|
||||
#ifndef ADD_MAIN_H
|
||||
#define ADD_MAIN_H
|
||||
|
||||
/**
|
||||
* @fn error_checking
|
||||
*/
|
||||
/**
|
||||
* @fn print_message
|
||||
*/
|
||||
/**
|
||||
* @fn printing_head
|
||||
*/
|
||||
/**
|
||||
* @fn set_defaults
|
||||
*/
|
||||
|
||||
int error_checking (const float *, const int, const char *, const int, const int *,
|
||||
const char *, const int);
|
||||
int print_message (const int, FILE *, const int, FILE *, const int, const char *);
|
||||
int printing_head (const char *, const int, const int, const int, const char *,
|
||||
const int, const int, const float *, const int, const double,
|
||||
const double, const double, const double, const double, const double,
|
||||
const int *);
|
||||
int set_defaults (float *, float *, float *, float *, int *, char *, int *, int *,
|
||||
float *, float *, float *, char *, int *, int *);
|
||||
|
||||
#endif /* ADD_MAIN_H */
|
||||
348
mathmech/radf/src/main.c
Normal file
348
mathmech/radf/src/main.c
Normal file
@ -0,0 +1,348 @@
|
||||
/**
|
||||
* @file
|
||||
*/
|
||||
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "add_main.h"
|
||||
#include <mathmech/coords.h>
|
||||
#include <mathmech/messages.h>
|
||||
#include <mathmech/radf.h>
|
||||
#include <mathmech/radf_proc.h>
|
||||
|
||||
|
||||
/**
|
||||
* @fn main
|
||||
*/
|
||||
int main(int argc, char *argv[])
|
||||
/**
|
||||
* @return 1 - error in error_checking
|
||||
* @return 2 - input file does not exist
|
||||
* @return 3 - memory error
|
||||
* @return 4 - unknown flag
|
||||
* @return 0 - exit without errors
|
||||
*/
|
||||
{
|
||||
char filename[256], tmp_str[2048];
|
||||
int error, i, j;
|
||||
FILE *f_inp, *f_log;
|
||||
|
||||
char input[256], logfile[256], output[256];
|
||||
float ang_max, ang_min, ang_step, cell[3], *coords, r_max, r_min, r_step;
|
||||
int from, *label_mol, log, matrix, mode, num_atoms, num_mol, num_needed_at,
|
||||
needed_at[6], quiet, *radf, step, to, *true_label_mol, *type_atoms;
|
||||
|
||||
/* input input file name
|
||||
* logfile log file name
|
||||
* output output file name
|
||||
*
|
||||
* ang_max maximal angle for RADF
|
||||
* ang_min minimal angle for RADF
|
||||
* ang_step anlge step for RADF
|
||||
* cell massive of cell size
|
||||
* coords massive of coordinates
|
||||
* r_max maximal radius
|
||||
* r_min minimal radius
|
||||
* r_step radius step
|
||||
*
|
||||
* from first trajectory step
|
||||
* label_mol massive of numbers of molecule for atoms
|
||||
* log status of log-mode
|
||||
* matrix status of matrix-mode
|
||||
* mode 0 - if RDF, 1 - if RDF for center mass, 2 - if RADF
|
||||
* num_atoms number of atoms
|
||||
* num_mol number of molecules
|
||||
* num_needed_at number of needed atom types
|
||||
* needed_at massive of number of needed atom types
|
||||
* quiet status of quiet-mode
|
||||
* radf not normed RADF
|
||||
* step $(to - from + 1)
|
||||
* to last trajectory step
|
||||
* true_label_mol massive of true numbers of molecule for atoms
|
||||
* type_atoms massive of atom types
|
||||
*/
|
||||
|
||||
set_defaults (&ang_max, &ang_min, &ang_step, cell, &from, input, &log, &matrix,
|
||||
&r_max, &r_min, &r_step, output, &to, &quiet);
|
||||
|
||||
for (i=1; i<argc; i++)
|
||||
{
|
||||
if ((argv[i][0] == '-') && (argv[i][1] == 'h') && (argv[i][2] == '\0'))
|
||||
{
|
||||
sprintf (tmp_str, " mm_radf\n");
|
||||
sprintf (tmp_str, "%sProgram that calculates radial distribution function (RDF) or radial-angles\n", tmp_str);
|
||||
sprintf (tmp_str, "%sdistribution function\n", tmp_str);
|
||||
sprintf (tmp_str, "%sVersion : 1.1.1 License : GPL\n", tmp_str);
|
||||
sprintf (tmp_str, "%s Evgeniy Alekseev aka arcanis\n", tmp_str);
|
||||
sprintf (tmp_str, "%s E-mail : esalexeev@gmail.com\n\n", tmp_str);
|
||||
sprintf (tmp_str, "%sUsage:\n", tmp_str);
|
||||
sprintf (tmp_str, "%smm_radf -i INPUT -s FIRST,LAST -c X,Y,Z -at ... -o OUTPUT [ -r MIN,MAX ] [ -rs R_STEP ]\n", tmp_str);
|
||||
sprintf (tmp_str, "%s [ -a MIN,MAX ] [ -as ANG_STEP ] [ -m ] [ -l LOGFILE ] [ -q ] [ -h ]\n\n", tmp_str);
|
||||
sprintf (tmp_str, "%sParametrs:\n", tmp_str);
|
||||
sprintf (tmp_str, "%s -i - mask of input files\n", tmp_str);
|
||||
sprintf (tmp_str, "%s -s - trajectory steps (integer)\n", tmp_str);
|
||||
sprintf (tmp_str, "%s -c - cell size (float), A\n", tmp_str);
|
||||
sprintf (tmp_str, "%s -at - atom types (integer). Format: 'ATOM1-ATOM2' or 'A1,A2,A3-B1,B2,B3'\n", tmp_str);
|
||||
sprintf (tmp_str, "%s (will enable RDF calculation for center mass automaticaly)\n", tmp_str);
|
||||
sprintf (tmp_str, "%s -o - output file name\n", tmp_str);
|
||||
sprintf (tmp_str, "%s -r - minimal and maximal radii for analyze (float), A. Default is '2.0,15.0'\n", tmp_str);
|
||||
sprintf (tmp_str, "%s -rs - radius step for analyze (float), A. Default is '0.2'\n", tmp_str);
|
||||
sprintf (tmp_str, "%s -a - minimal and maximal angles for analyze (float), deg. Default is '0.0,90.0'\n", tmp_str);
|
||||
sprintf (tmp_str, "%s -as - angle step for analyze (float), deg. This option will enable RADF\n", tmp_str);
|
||||
sprintf (tmp_str, "%s calculation automaticaly\n", tmp_str);
|
||||
sprintf (tmp_str, "%s -m - matrix output enable\n", tmp_str);
|
||||
sprintf (tmp_str, "%s -l - log enable\n", tmp_str);
|
||||
sprintf (tmp_str, "%s -q - quiet enable\n", tmp_str);
|
||||
sprintf (tmp_str, "%s -h - show this help and exit\n", tmp_str);
|
||||
fputs (tmp_str, stdout);
|
||||
return 0;
|
||||
}
|
||||
else if ((argv[i][0] == '-') && (argv[i][1] == 'i') && (argv[i][2] == '\0'))
|
||||
// input file
|
||||
{
|
||||
strcpy (input, argv[i+1]);
|
||||
i++;
|
||||
}
|
||||
else if ((argv[i][0] == '-') && (argv[i][1] == 's') && (argv[i][2] == '\0'))
|
||||
// steps
|
||||
{
|
||||
sscanf (argv[i+1], "%i,%i", &from, &to);
|
||||
if (from > to)
|
||||
{
|
||||
to += from;
|
||||
from = to - from;
|
||||
to -= from;
|
||||
}
|
||||
step = to - from + 1;
|
||||
i++;
|
||||
}
|
||||
else if ((argv[i][0] == '-') && (argv[i][1] == 'c') && (argv[i][2] == '\0'))
|
||||
// cell size
|
||||
{
|
||||
sscanf (argv[i+1], "%f,%f,%f", &cell[0], &cell[1], &cell[2]);
|
||||
i++;
|
||||
}
|
||||
else if ((argv[i][0] == '-') && (argv[i][1] == 'a') && (argv[i][2] == 't') && (argv[i][3] == '\0'))
|
||||
// atom types
|
||||
{
|
||||
num_needed_at = 2;
|
||||
for (j=0; j<strlen(argv[i+1]); j++)
|
||||
if (argv[i+1][j] == ',')
|
||||
num_needed_at++;
|
||||
if (num_needed_at == 2)
|
||||
sscanf (argv[i+1], "%i-%i", &needed_at[0], &needed_at[1]);
|
||||
else if (num_needed_at == 6)
|
||||
sscanf (argv[i+1], "%i,%i,%i-%i,%i,%i", &needed_at[0], &needed_at[1], &needed_at[2],
|
||||
&needed_at[3], &needed_at[4], &needed_at[5]);
|
||||
i++;
|
||||
}
|
||||
else if ((argv[i][0] == '-') && (argv[i][1] == 'o') && (argv[i][2] == '\0'))
|
||||
// output file
|
||||
{
|
||||
strcpy (output, argv[i+1]);
|
||||
i++;
|
||||
}
|
||||
else if ((argv[i][0] == '-') && (argv[i][1] == 'r') && (argv[i][2] == '\0'))
|
||||
// radii
|
||||
{
|
||||
sscanf (argv[i+1], "%f,%f", &r_min, &r_max);
|
||||
if (r_min > r_max)
|
||||
{
|
||||
r_min += r_max;
|
||||
r_max = r_min - r_max;
|
||||
r_min -= r_max;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
else if ((argv[i][0] == '-') && (argv[i][1] == 'r') && (argv[i][2] == 's') && (argv[i][3] == '\0'))
|
||||
// radius step
|
||||
{
|
||||
sscanf (argv[i+1], "%f", &r_step);
|
||||
i++;
|
||||
}
|
||||
else if ((argv[i][0] == '-') && (argv[i][1] == 'a') && (argv[i][2] == '\0'))
|
||||
// angles
|
||||
{
|
||||
sscanf (argv[i+1], "%f,%f", &ang_min, &ang_max);
|
||||
if (ang_min > ang_max)
|
||||
{
|
||||
ang_min += ang_max;
|
||||
ang_max = ang_min - ang_max;
|
||||
ang_min -= ang_max;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
else if ((argv[i][0] == '-') && (argv[i][1] == 'a') && (argv[i][2] == 's') && (argv[i][3] == '\0'))
|
||||
// angle step
|
||||
{
|
||||
sscanf (argv[i+1], "%f", &ang_step);
|
||||
i++;
|
||||
}
|
||||
else if ((argv[i][0] == '-') && (argv[i][1] == 'm') && (argv[i][2] == '\0'))
|
||||
// matrix mode
|
||||
{
|
||||
matrix = 1;
|
||||
}
|
||||
else if ((argv[i][0] == '-') && (argv[i][1] == 'l') && (argv[i][2] == '\0'))
|
||||
// log mode
|
||||
{
|
||||
log = 1;
|
||||
strcpy (logfile, argv[i+1]);
|
||||
i++;
|
||||
}
|
||||
else if ((argv[i][0] == '-') && (argv[i][1] == 'q') && (argv[i][2] == '\0'))
|
||||
// quiet mode
|
||||
{
|
||||
quiet = 1;
|
||||
}
|
||||
else
|
||||
// unknown flag
|
||||
{
|
||||
return 4;
|
||||
}
|
||||
}
|
||||
|
||||
if (log == 1)
|
||||
f_log = fopen (logfile, "w");
|
||||
|
||||
print_message (quiet, stdout, log, f_log, 0, argv[0]);
|
||||
print_message (quiet, stdout, log, f_log, 1, argv[0]);
|
||||
|
||||
// error check
|
||||
error = error_checking (cell, from, input, num_needed_at, needed_at, output, to);
|
||||
if (error != 0)
|
||||
{
|
||||
print_message (quiet, stderr, log, f_log, 17, argv[0]);
|
||||
return 1;
|
||||
}
|
||||
|
||||
print_message (quiet, stdout, log, f_log, 2, argv[0]);
|
||||
|
||||
// processing
|
||||
// initial variables
|
||||
// set mode
|
||||
if ((num_needed_at == 6) && (ang_step != 0.0))
|
||||
mode = 2;
|
||||
else if (num_needed_at == 6)
|
||||
mode = 1;
|
||||
else if (num_needed_at == 2)
|
||||
mode = 0;
|
||||
|
||||
sprintf (filename, "%s.%03i", input, from);
|
||||
print_message (quiet, stdout, log, f_log, 3, filename);
|
||||
f_inp = fopen (filename, "r");
|
||||
if (f_inp == NULL)
|
||||
{
|
||||
print_message (quiet, stderr, log, f_log, 18, filename);
|
||||
return 2;
|
||||
}
|
||||
fscanf (f_inp, "%i", &num_atoms);
|
||||
fclose (f_inp);
|
||||
coords = (float *) malloc (2 * 3 * 8 * num_atoms * sizeof (float));
|
||||
label_mol = (int *) malloc (2 * 8 * num_atoms * sizeof (int));
|
||||
if (mode == 2)
|
||||
{
|
||||
i = (r_max - r_min) / r_step;
|
||||
j = (ang_max - ang_min) / ang_step;
|
||||
i *= j;
|
||||
}
|
||||
else
|
||||
i = (r_max - r_min) / r_step;
|
||||
radf = (int *) malloc (i * sizeof (int));
|
||||
for (j=0; j<i; j++)
|
||||
radf[j] = 0;
|
||||
true_label_mol = (int *) malloc (num_atoms * sizeof (int));
|
||||
type_atoms = (int *) malloc (2 * 8 * num_atoms * sizeof (int));
|
||||
// error checking
|
||||
if ((coords == NULL) ||
|
||||
(label_mol == NULL) ||
|
||||
(radf == NULL) ||
|
||||
(true_label_mol == NULL) ||
|
||||
(type_atoms == NULL))
|
||||
{
|
||||
print_message (quiet, stderr, log, f_log, 19, argv[0]);
|
||||
return 3;
|
||||
}
|
||||
sprintf (tmp_str, "%6cOutput file: '%s';\n%6cLog: %i;\n%6cQuiet: %i;\n%6cMatrix mode: %i;\n\
|
||||
%6cMask: %s;\n%6cFirst step: %i;\n%6cLast step: %i;\n%6cCell size: %.4f, %.4f, %.4f;\n%6cMode: %i;\n\
|
||||
%6cR_MIN: %6.3f; R_MAX: %6.3f; R_STEP: %6.3f;\n", ' ', output, ' ', log, ' ', quiet, ' ', matrix,
|
||||
' ', input, ' ', from, ' ', to, ' ', cell[0], cell[1], cell[2], ' ', mode, ' ', r_min, r_max, r_step);
|
||||
switch (mode)
|
||||
{
|
||||
case 0:
|
||||
sprintf (tmp_str, "%s%6cATOM TYPES: %i-%i\n", tmp_str, ' ', needed_at[0], needed_at[1]);
|
||||
break;
|
||||
case 1:
|
||||
sprintf (tmp_str, "%s%6cATOM TYPES: %i,%i,%i-%i,%i,%i\n", tmp_str, ' ', needed_at[0], needed_at[1],
|
||||
needed_at[2], needed_at[3], needed_at[4], needed_at[5]);
|
||||
break;
|
||||
case 2:
|
||||
sprintf (tmp_str, "%s%6cANG_MIN: %6.2f; ANG_MAX: %6.2f; ANG_STEP: %6.2f;\n\
|
||||
%6cATOM TYPES: %i,%i,%i-%i,%i,%i\n", tmp_str, ' ', ang_min, ang_max, ang_step, ' ', needed_at[0],
|
||||
needed_at[1], needed_at[2], needed_at[3], needed_at[4], needed_at[5]);
|
||||
break;
|
||||
}
|
||||
print_message (quiet, stdout, log, f_log, 5, tmp_str);
|
||||
|
||||
// head
|
||||
printing_head (output, log, quiet, matrix, input, from, to, cell, mode, r_min,
|
||||
r_max, r_step, ang_min, ang_max, ang_step, needed_at);
|
||||
|
||||
print_message (quiet, stdout, log, f_log, 6, argv[0]);
|
||||
// main cycle
|
||||
for (i=from; i<to+1; i++)
|
||||
{
|
||||
sprintf (filename, "%s.%03i", input, i);
|
||||
print_message (quiet, stdout, log, f_log, 7, filename);
|
||||
error = reading_coords (0, filename, num_needed_at, needed_at, cell, &num_mol,
|
||||
&num_atoms, true_label_mol, label_mol, type_atoms,
|
||||
coords, tmp_str);
|
||||
if (error == 0)
|
||||
{
|
||||
sprintf (tmp_str, "%6cNumber of molecules: %i; %6cNumber of atoms: %i\n",
|
||||
' ', num_mol, ' ', num_atoms);
|
||||
print_message (quiet, stdout, log, f_log, 8, tmp_str);
|
||||
error = 1;
|
||||
switch (mode)
|
||||
{
|
||||
case 0:
|
||||
error = search_rdf (num_atoms, type_atoms, label_mol, coords, r_min,
|
||||
r_max, r_step, radf);
|
||||
break;
|
||||
case 1:
|
||||
error = search_rdf_centr (num_atoms, type_atoms, label_mol, coords, r_min,
|
||||
r_max, r_step, radf);
|
||||
if (error == 0)
|
||||
case 2:
|
||||
error = search_radf (num_atoms, type_atoms, label_mol, coords, r_min, r_max,
|
||||
r_step, ang_min, ang_max, ang_step, radf);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (error == 0)
|
||||
print_message (quiet, stdout, log, f_log, 22, argv[0]);
|
||||
}
|
||||
|
||||
print_message (quiet, stdout, log, f_log, 13, argv[0]);
|
||||
print_message (quiet, stdout, log, f_log, 14, output);
|
||||
// tail
|
||||
print_result (output, matrix, mode, step, num_atoms, r_min, r_max, r_step, ang_min,
|
||||
ang_max, ang_step, cell, radf);
|
||||
|
||||
print_message (quiet, stdout, log, f_log, 15, argv[0]);
|
||||
// free memory
|
||||
free (coords);
|
||||
free (label_mol);
|
||||
free (radf);
|
||||
free (type_atoms);
|
||||
free (true_label_mol);
|
||||
|
||||
print_message (quiet, stdout, log, f_log, 16, argv[0]);
|
||||
|
||||
if (log == 1)
|
||||
fclose (f_log);
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user