/*******************************************************************************
*
* McStas, neutron ray-tracing package
* Copyright 1997-2002, All rights reserved
* Risoe National Laboratory, Roskilde, Denmark
* Institut Laue Langevin, Grenoble, France
*
* Library: share/monitor_nd-lib.c
*
* %Identification
* Written by: EF
* Date: Aug 28, 2002
* Origin: ILL
* Release: McStas 1.6
* Version: $Revision: 1.32 $
*
* This file is to be imported by the monitor_nd related components
* It handles some shared functions. Embedded within instrument in runtime mode.
* Variable names have prefix 'mc_mn_' for 'McStas Monitor' to avoid conflicts
*
* Usage: within SHARE
* %include "monitor_nd-lib"
*
* $Id: monitor_nd-lib.c,v 1.32 2005/09/19 15:13:53 farhi Exp $
*
* $Log: monitor_nd-lib.c,v $
* Revision 1.32 2005/09/19 15:13:53 farhi
* using 'y' variable also sets limits to detector dimensions, to enable 'banana' view without troubles.
*
* Revision 1.31 2005/09/16 08:43:19 farhi
* Removed floor+0.5 in Monitor_nD
* Take care of ploting with bin centers in mcplot stuff (inline+matlab+scilab+octave...)
*
* Revision 1.30 2005/08/24 13:14:00 lieutenant
* new option 'exclusive'
*
* Revision 1.29 2005/07/25 14:55:08 farhi
* DOC update:
* checked all parameter [unit] + text to be OK
* set all versions to CVS Revision
*
* Revision 1.28 2005/07/18 14:38:00 farhi
* Added 0.5 top all floor's so that bin are centered (at last)
*
* Revision 1.27 2005/07/06 08:16:28 farhi
* Misprint for Kxy/Vxy. Better Variable name as well.
*
* Revision 1.26 2005/07/04 08:19:50 farhi
* added support for kxy and vxy radial distributions
*
* Revision 1.25 2005/04/11 11:40:44 farhi
* Added missing n-dims argument to printf for capture flux warning
*
* Revision 1.24 2005/03/14 10:48:54 farhi
* Added warning when setting capture flux (meaningful with integral flux) for
* more than 1 bin.
*
* Revision 1.23 2005/02/25 15:26:02 farhi
* Removed usage of round function
* made Guide_honeycomb work with gravitation
*
* Revision 1.22 2005/02/22 16:11:03 farhi
* Now saving absolute position of monitors as "position" field in header
* Useful for plotting e.g. flux vs distance
*
* Revision 1.21 2005/02/21 16:05:13 farhi
* Misprint correction
*
* Revision 1.20 2005/02/21 12:38:03 farhi
* Removed warning in Monitor_nD for global scope keywords in options
*
* Revision 1.19 2005/02/17 16:06:32 farhi
* Added 'per bin' to labels if more than 1 bin, and a message for unknow keywords found in options parameter. Requested by R. Cubitt.
*
* Revision 1.18 2004/11/16 13:36:35 farhi
* Paging update
*
* Revision 1.17 2004/09/01 13:54:18 farhi
* Corrected bug when using list=EVNTS large values written as float, read as int.
* E.g. 1e6 gave 1 as number of events to save !
*
* Revision 1.16 2004/06/30 12:13:47 farhi
* For lists (and Res_monitor), uses 'list' 'no header' and 'no footer' options
* in mcformat.Name so that catenated file does contain only one instance of
* footer and header.
*
* Revision 1.15 2004/02/26 12:55:41 farhi
* Handles 0d monitor outputs for bins=0, and limits are restrictive (i.e. neutron must be within all limits to be stored in monitor)
*
* Revision 1.14 2004/02/04 18:01:12 farhi
* Use hdiv=theta and vdiv=phi for banana.
*
* Revision 1.13 2003/08/26 12:33:27 farhi
* Corrected computation of angle PHI (was projected on vertical plane)
*
* Revision 1.12 2003/04/15 16:01:28 farhi
* incoming/outgoing syntax mismatch correction
*
* Revision 1.11 2003/04/15 15:45:56 farhi
* outgoing time is default (vs. incoming)
*
* Revision 1.10 2003/04/09 15:49:25 farhi
* corrected bug when no signal and auto limits requested
*
* Revision 1.9 2003/02/18 09:11:36 farhi
* Corrected binary format for lists
*
* Revision 1.1 2002/08/28 11:39:00 ef
* Initial revision extracted from lib/monitors/Monitor_nD.comp
*******************************************************************************/
#ifndef MONITOR_ND_LIB_H
#error McStas : please import this library with %include "monitor_nd-lib"
#endif
/* ========================================================================= */
/* ADD: E.Farhi, Aug 6th, 2001: Monitor_nD section */
/* this routine is used to parse options */
/* ========================================================================= */
void Monitor_nD_Init(MonitornD_Defines_type *mc_mn_DEFS,
MonitornD_Variables_type *mc_mn_Vars,
MCNUM mc_mn_xwidth,
MCNUM mc_mn_yheight,
MCNUM mc_mn_zthick,
MCNUM mc_mn_xmin,
MCNUM mc_mn_xmax,
MCNUM mc_mn_ymin,
MCNUM mc_mn_ymax,
MCNUM mc_mn_zmin,
MCNUM mc_mn_zmax)
{
long mc_mn_carg = 1;
char *mc_mn_option_copy, *mc_mn_token;
char mc_mn_Flag_New_token = 1;
char mc_mn_Flag_End = 1;
char mc_mn_Flag_All = 0;
char mc_mn_Flag_No = 0;
char mc_mn_Flag_abs = 0;
int mc_mn_Flag_auto = 0; /* -1: all, 1: the current variable */
int mc_mn_Set_Vars_Coord_Type;
char mc_mn_Set_Vars_Coord_Label[30];
char mc_mn_Set_Vars_Coord_Var[30];
char mc_mn_Short_Label[MONnD_COORD_NMAX][30];
int mc_mn_Set_Coord_Mode;
long mc_mn_i=0, mc_mn_j=0;
double mc_mn_lmin, mc_mn_lmax, mc_mn_XY;
long mc_mn_t;
mc_mn_t = (long)time(NULL);
mc_mn_DEFS->COORD_NONE =0;
mc_mn_DEFS->COORD_X =1;
mc_mn_DEFS->COORD_Y =2;
mc_mn_DEFS->COORD_Z =3;
mc_mn_DEFS->COORD_VX =4;
mc_mn_DEFS->COORD_VY =5;
mc_mn_DEFS->COORD_VZ =6;
mc_mn_DEFS->COORD_T =7;
mc_mn_DEFS->COORD_P =8;
mc_mn_DEFS->COORD_SX =9;
mc_mn_DEFS->COORD_SY =10;
mc_mn_DEFS->COORD_SZ =11;
mc_mn_DEFS->COORD_KX =12;
mc_mn_DEFS->COORD_KY =13;
mc_mn_DEFS->COORD_KZ =14;
mc_mn_DEFS->COORD_K =15;
mc_mn_DEFS->COORD_V =16;
mc_mn_DEFS->COORD_ENERGY =17;
mc_mn_DEFS->COORD_LAMBDA =18;
mc_mn_DEFS->COORD_RADIUS =19;
mc_mn_DEFS->COORD_HDIV =20;
mc_mn_DEFS->COORD_VDIV =21;
mc_mn_DEFS->COORD_ANGLE =22;
mc_mn_DEFS->COORD_NCOUNT =23;
mc_mn_DEFS->COORD_THETA =24;
mc_mn_DEFS->COORD_PHI =25;
mc_mn_DEFS->COORD_USER1 =26;
mc_mn_DEFS->COORD_USER2 =27;
mc_mn_DEFS->COORD_KXY =28;
mc_mn_DEFS->COORD_VXY =29;
/* mc_mn_token modifiers */
mc_mn_DEFS->COORD_VAR =0; /* next mc_mn_token should be a variable or normal option */
mc_mn_DEFS->COORD_MIN =1; /* next mc_mn_token is a min value */
mc_mn_DEFS->COORD_MAX =2; /* next mc_mn_token is a max value */
mc_mn_DEFS->COORD_DIM =3; /* next mc_mn_token is a bin value */
mc_mn_DEFS->COORD_FIL =4; /* next mc_mn_token is a filename */
mc_mn_DEFS->COORD_EVNT =5; /* next mc_mn_token is a buffer size value */
mc_mn_DEFS->COORD_3HE =6; /* next mc_mn_token is a 3He pressure value */
mc_mn_DEFS->COORD_INTERM =7; /* next mc_mn_token is an intermediate save value (%) */
mc_mn_DEFS->COORD_LOG =32; /* next variable will be in log scale */
mc_mn_DEFS->COORD_ABS =64; /* next variable will be in abs scale */
mc_mn_DEFS->COORD_SIGNAL =128; /* next variable will be the signal var */
mc_mn_DEFS->COORD_AUTO =256; /* set auto limits */
strcpy(mc_mn_DEFS->TOKEN_DEL, " =,;[](){}:"); /* mc_mn_token separators */
mc_mn_DEFS->SHAPE_SQUARE =0; /* shape of the monitor */
mc_mn_DEFS->SHAPE_DISK =1;
mc_mn_DEFS->SHAPE_SPHERE =2;
mc_mn_DEFS->SHAPE_CYLIND =3;
mc_mn_DEFS->SHAPE_BANANA =4;
mc_mn_DEFS->SHAPE_BOX =5;
mc_mn_Vars->Sphere_Radius = 0;
mc_mn_Vars->Cylinder_Height = 0;
mc_mn_Vars->Flag_With_Borders = 0; /* 2 means xy borders too */
mc_mn_Vars->Flag_List = 0; /* 1=store 1 buffer, 2=list all, 3=re-use buffer */
mc_mn_Vars->Flag_Multiple = 0; /* 1 when n1D, 0 for 2D */
mc_mn_Vars->Flag_Verbose = 0;
mc_mn_Vars->Flag_Shape = mc_mn_DEFS->SHAPE_SQUARE;
mc_mn_Vars->Flag_Auto_Limits = 0; /* get limits from first Buffer */
mc_mn_Vars->Flag_Absorb = 0; /* monitor is also a slit */
mc_mn_Vars->Flag_Exclusive = 0; /* absorb neutrons out of monitor limits */
mc_mn_Vars->Flag_per_cm2 = 0; /* flux is per cm2 */
mc_mn_Vars->Flag_log = 0; /* log10 of the flux */
mc_mn_Vars->Flag_parallel = 0; /* set neutron state back after detection (parallel components) */
mc_mn_Vars->Flag_Binary_List = 0; /* save list as a binary file (smaller) */
mc_mn_Vars->Coord_Number = 0; /* total number of variables to monitor, plus intensity (0) */
mc_mn_Vars->Buffer_Block = 10000; /* Buffer size for list or auto limits */
mc_mn_Vars->Neutron_Counter = 0; /* event counter, simulation total counts is mcget_ncount() */
mc_mn_Vars->Buffer_Counter = 0; /* mc_mn_index in Buffer size (for realloc) */
mc_mn_Vars->Buffer_Size = 0;
mc_mn_Vars->UserVariable1 = 0;
mc_mn_Vars->UserVariable2 = 0;
mc_mn_Vars->He3_pressure = 0;
mc_mn_Vars->IntermediateCnts = 0;
mc_mn_Vars->Flag_capture = 0;
mc_mn_Vars->Flag_signal = mc_mn_DEFS->COORD_P;
mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_NONE;
mc_mn_Set_Coord_Mode = mc_mn_DEFS->COORD_VAR;
/* handle size parameters */
/* normal use is with xwidth, yheight, zthick */
/* if xmin,xmax,ymin,ymax,zmin,zmax are non 0, use them */
if (fabs(mc_mn_xmin-mc_mn_xmax) == 0)
{ mc_mn_Vars->mxmin = -fabs(mc_mn_xwidth)/2; mc_mn_Vars->mxmax = fabs(mc_mn_xwidth)/2; }
else
{ if (mc_mn_xmin < mc_mn_xmax) {mc_mn_Vars->mxmin = mc_mn_xmin; mc_mn_Vars->mxmax = mc_mn_xmax;}
else {mc_mn_Vars->mxmin = mc_mn_xmax; mc_mn_Vars->mxmax = mc_mn_xmin;}
}
if (fabs(mc_mn_ymin-mc_mn_ymax) == 0)
{ mc_mn_Vars->mymin = -fabs(mc_mn_yheight)/2; mc_mn_Vars->mymax = fabs(mc_mn_yheight)/2; }
else
{ if (mc_mn_ymin < mc_mn_ymax) {mc_mn_Vars->mymin = mc_mn_ymin; mc_mn_Vars->mymax = mc_mn_ymax;}
else {mc_mn_Vars->mymin = mc_mn_ymax; mc_mn_Vars->mymax = mc_mn_ymin;}
}
if (fabs(mc_mn_zmin-mc_mn_zmax) == 0)
{ mc_mn_Vars->mzmin = -fabs(mc_mn_zthick)/2; mc_mn_Vars->mzmax = fabs(mc_mn_zthick)/2; }
else
{ if (mc_mn_zmin < mc_mn_zmax) {mc_mn_Vars->mzmin = mc_mn_zmin; mc_mn_Vars->mzmax = mc_mn_zmax; }
else {mc_mn_Vars->mzmin = mc_mn_zmax; mc_mn_Vars->mzmax = mc_mn_zmin; }
}
if (fabs(mc_mn_Vars->mzmax-mc_mn_Vars->mzmin) == 0)
mc_mn_Vars->Flag_Shape = mc_mn_DEFS->SHAPE_SQUARE;
else
mc_mn_Vars->Flag_Shape = mc_mn_DEFS->SHAPE_BOX;
/* parse option string */
mc_mn_option_copy = (char*)malloc(strlen(mc_mn_Vars->option)+1);
if (mc_mn_option_copy == NULL)
{
fprintf(stderr,"Monitor_nD: %s cannot allocate mc_mn_option_copy (%li). Fatal.\n", mc_mn_Vars->compcurname, strlen(mc_mn_Vars->option));
exit(-1);
}
if (strlen(mc_mn_Vars->option))
{
mc_mn_Flag_End = 0;
strcpy(mc_mn_option_copy, mc_mn_Vars->option);
}
if (strstr(mc_mn_Vars->option, "cm2") || strstr(mc_mn_Vars->option, "cm^2")) mc_mn_Vars->Flag_per_cm2 = 1;
if (strstr(mc_mn_Vars->option, "binary") || strstr(mc_mn_Vars->option, "float"))
mc_mn_Vars->Flag_Binary_List = 1;
if (strstr(mc_mn_Vars->option, "double"))
mc_mn_Vars->Flag_Binary_List = 2;
if (mc_mn_Vars->Flag_per_cm2) strncpy(mc_mn_Vars->Coord_Label[0],"Intensity [n/cm^2/s]",30);
else strncpy(mc_mn_Vars->Coord_Label[0],"Intensity [n/s]",30);
strncpy(mc_mn_Vars->Coord_Var[0],"p",30);
mc_mn_Vars->Coord_Type[0] = mc_mn_DEFS->COORD_P;
mc_mn_Vars->Coord_Bin[0] = 1;
mc_mn_Vars->Coord_Min[0] = 0;
mc_mn_Vars->Coord_Max[0] = FLT_MAX;
/* default file name is comp name+dateID */
sprintf(mc_mn_Vars->Mon_File, "%s_%li", mc_mn_Vars->compcurname, mc_mn_t);
mc_mn_carg = 1;
while((mc_mn_Flag_End == 0) && (mc_mn_carg < 128))
{
if (mc_mn_Flag_New_token) /* to get the previous mc_mn_token sometimes */
{
if (mc_mn_carg == 1) mc_mn_token=(char *)strtok(mc_mn_option_copy,mc_mn_DEFS->TOKEN_DEL);
else mc_mn_token=(char *)strtok(NULL,mc_mn_DEFS->TOKEN_DEL);
if (mc_mn_token == NULL) mc_mn_Flag_End=1;
}
mc_mn_Flag_New_token = 1;
if ((mc_mn_token != NULL) && (strlen(mc_mn_token) != 0))
{
char mc_mn_iskeyword=0;
int mc_mn_old_Mode;
/* first handle option values from preceeding keyword mc_mn_token detected */
mc_mn_old_Mode = mc_mn_Set_Coord_Mode;
if (mc_mn_Set_Coord_Mode == mc_mn_DEFS->COORD_MAX)
{
if (!mc_mn_Flag_All)
mc_mn_Vars->Coord_Max[mc_mn_Vars->Coord_Number] = atof(mc_mn_token);
else
for (mc_mn_i = 0; mc_mn_i <= mc_mn_Vars->Coord_Number; mc_mn_Vars->Coord_Max[mc_mn_i++] = atof(mc_mn_token));
mc_mn_Set_Coord_Mode = mc_mn_DEFS->COORD_VAR; mc_mn_Flag_All = 0;
}
if (mc_mn_Set_Coord_Mode == mc_mn_DEFS->COORD_MIN)
{
if (!mc_mn_Flag_All)
mc_mn_Vars->Coord_Min[mc_mn_Vars->Coord_Number] = atof(mc_mn_token);
else
for (mc_mn_i = 0; mc_mn_i <= mc_mn_Vars->Coord_Number; mc_mn_Vars->Coord_Min[mc_mn_i++] = atof(mc_mn_token));
mc_mn_Set_Coord_Mode = mc_mn_DEFS->COORD_MAX;
}
if (mc_mn_Set_Coord_Mode == mc_mn_DEFS->COORD_DIM)
{
if (!mc_mn_Flag_All)
mc_mn_Vars->Coord_Bin[mc_mn_Vars->Coord_Number] = atoi(mc_mn_token);
else
for (mc_mn_i = 0; mc_mn_i <= mc_mn_Vars->Coord_Number; mc_mn_Vars->Coord_Bin[mc_mn_i++] = atoi(mc_mn_token));
mc_mn_Set_Coord_Mode = mc_mn_DEFS->COORD_VAR; mc_mn_Flag_All = 0;
}
if (mc_mn_Set_Coord_Mode == mc_mn_DEFS->COORD_FIL)
{
if (!mc_mn_Flag_No) strncpy(mc_mn_Vars->Mon_File,mc_mn_token,128);
else { strcpy(mc_mn_Vars->Mon_File,""); mc_mn_Vars->Coord_Number = 0; mc_mn_Flag_End = 1;}
mc_mn_Set_Coord_Mode = mc_mn_DEFS->COORD_VAR;
}
if (mc_mn_Set_Coord_Mode == mc_mn_DEFS->COORD_EVNT)
{
if (!strcmp(mc_mn_token, "all") || mc_mn_Flag_All) mc_mn_Vars->Flag_List = 2;
else { mc_mn_i = (long)ceil(atof(mc_mn_token)); if (mc_mn_i) mc_mn_Vars->Buffer_Block = mc_mn_i;
mc_mn_Vars->Flag_List = 1; }
mc_mn_Set_Coord_Mode = mc_mn_DEFS->COORD_VAR; mc_mn_Flag_All = 0;
}
if (mc_mn_Set_Coord_Mode == mc_mn_DEFS->COORD_3HE)
{
mc_mn_Vars->He3_pressure = atof(mc_mn_token);
mc_mn_Set_Coord_Mode = mc_mn_DEFS->COORD_VAR; mc_mn_Flag_All = 0;
}
if (mc_mn_Set_Coord_Mode == mc_mn_DEFS->COORD_INTERM)
{
mc_mn_Vars->Intermediate = atof(mc_mn_token);
mc_mn_Set_Coord_Mode = mc_mn_DEFS->COORD_VAR; mc_mn_Flag_All = 0;
}
/* now look for general option keywords */
if (!strcmp(mc_mn_token, "borders")) {mc_mn_Vars->Flag_With_Borders = 1; mc_mn_iskeyword=1; }
if (!strcmp(mc_mn_token, "verbose")) {mc_mn_Vars->Flag_Verbose = 1; mc_mn_iskeyword=1; }
if (!strcmp(mc_mn_token, "log")) {mc_mn_Vars->Flag_log = 1; mc_mn_iskeyword=1; }
if (!strcmp(mc_mn_token, "abs")) {mc_mn_Flag_abs = 1; mc_mn_iskeyword=1; }
if (!strcmp(mc_mn_token, "multiple")) {mc_mn_Vars->Flag_Multiple = 1; mc_mn_iskeyword=1; }
if (!strcmp(mc_mn_token, "exclusive")){mc_mn_Vars->Flag_Exclusive = 1; mc_mn_iskeyword=1; }
if (!strcmp(mc_mn_token, "list")) {
mc_mn_Vars->Flag_List = 1; mc_mn_Set_Coord_Mode = mc_mn_DEFS->COORD_EVNT; }
if (!strcmp(mc_mn_token, "limits") || !strcmp(mc_mn_token, "min"))
mc_mn_Set_Coord_Mode = mc_mn_DEFS->COORD_MIN;
if (!strcmp(mc_mn_token, "slit") || !strcmp(mc_mn_token, "absorb")) {
mc_mn_Vars->Flag_Absorb = 1; mc_mn_iskeyword=1; }
if (!strcmp(mc_mn_token, "max")) mc_mn_Set_Coord_Mode = mc_mn_DEFS->COORD_MAX;
if (!strcmp(mc_mn_token, "bins")) mc_mn_Set_Coord_Mode = mc_mn_DEFS->COORD_DIM;
if (!strcmp(mc_mn_token, "file")) {
mc_mn_Set_Coord_Mode = mc_mn_DEFS->COORD_FIL;
if (mc_mn_Flag_No) { strcpy(mc_mn_Vars->Mon_File,""); mc_mn_Vars->Coord_Number = 0; mc_mn_Flag_End = 1; }
}
if (!strcmp(mc_mn_token, "unactivate")) {
mc_mn_Flag_End = 1; mc_mn_Vars->Coord_Number = 0; mc_mn_iskeyword=1; }
if (!strcmp(mc_mn_token, "all")) { mc_mn_Flag_All = 1; mc_mn_iskeyword=1; }
if (!strcmp(mc_mn_token, "sphere")) { mc_mn_Vars->Flag_Shape = mc_mn_DEFS->SHAPE_SPHERE; mc_mn_iskeyword=1; }
if (!strcmp(mc_mn_token, "cylinder")) { mc_mn_Vars->Flag_Shape = mc_mn_DEFS->SHAPE_CYLIND; mc_mn_iskeyword=1; }
if (!strcmp(mc_mn_token, "banana")) { mc_mn_Vars->Flag_Shape = mc_mn_DEFS->SHAPE_BANANA; mc_mn_iskeyword=1; }
if (!strcmp(mc_mn_token, "square")) { mc_mn_Vars->Flag_Shape = mc_mn_DEFS->SHAPE_SQUARE; mc_mn_iskeyword=1; }
if (!strcmp(mc_mn_token, "disk")) { mc_mn_Vars->Flag_Shape = mc_mn_DEFS->SHAPE_DISK; mc_mn_iskeyword=1; }
if (!strcmp(mc_mn_token, "box")) { mc_mn_Vars->Flag_Shape = mc_mn_DEFS->SHAPE_BOX; mc_mn_iskeyword=1; }
if (!strcmp(mc_mn_token, "parallel")){ mc_mn_Vars->Flag_parallel = 1; mc_mn_iskeyword=1; }
if (!strcmp(mc_mn_token, "capture")) { mc_mn_Vars->Flag_capture = 1; mc_mn_iskeyword=1; }
if (!strcmp(mc_mn_token, "auto") && (mc_mn_Flag_auto != -1)) {
mc_mn_Vars->Flag_Auto_Limits = 1;
if (mc_mn_Flag_All) mc_mn_Flag_auto = -1;
else mc_mn_Flag_auto = 1;
mc_mn_iskeyword=1; }
if (!strcmp(mc_mn_token, "premonitor")) {
mc_mn_Vars->Flag_UsePreMonitor = 1; mc_mn_iskeyword=1; }
if (!strcmp(mc_mn_token, "3He_pressure")) {
mc_mn_Vars->He3_pressure = 3; mc_mn_iskeyword=1; }
if (!strcmp(mc_mn_token, "intermediate")) {
mc_mn_Set_Coord_Mode = mc_mn_DEFS->COORD_INTERM;
mc_mn_Vars->Intermediate = 5; mc_mn_iskeyword=1; }
if (!strcmp(mc_mn_token, "no") || !strcmp(mc_mn_token, "not")) { mc_mn_Flag_No = 1; mc_mn_iskeyword=1; }
if (!strcmp(mc_mn_token, "signal")) mc_mn_Set_Coord_Mode = mc_mn_DEFS->COORD_SIGNAL;
/* Mode has changed: this was a keyword or value */
if (mc_mn_Set_Coord_Mode != mc_mn_old_Mode) mc_mn_iskeyword=1;
/* now look for variable names to monitor */
mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_NONE; mc_mn_lmin = 0; mc_mn_lmax = 0;
if (!strcmp(mc_mn_token, "x"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_X; strcpy(mc_mn_Set_Vars_Coord_Label,"x [m]"); strcpy(mc_mn_Set_Vars_Coord_Var,"x");
mc_mn_lmin = mc_mn_Vars->mxmin; mc_mn_lmax = mc_mn_Vars->mxmax;
mc_mn_Vars->Coord_Min[mc_mn_Vars->Coord_Number] = mc_mn_Vars->mxmin;
mc_mn_Vars->Coord_Max[mc_mn_Vars->Coord_Number] = mc_mn_Vars->mxmax;}
if (!strcmp(mc_mn_token, "y"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_Y; strcpy(mc_mn_Set_Vars_Coord_Label,"y [m]"); strcpy(mc_mn_Set_Vars_Coord_Var,"y");
mc_mn_lmin = mc_mn_Vars->mymin; mc_mn_lmax = mc_mn_Vars->mymax;
mc_mn_Vars->Coord_Min[mc_mn_Vars->Coord_Number] = mc_mn_Vars->mymin;
mc_mn_Vars->Coord_Max[mc_mn_Vars->Coord_Number] = mc_mn_Vars->mymax;}
if (!strcmp(mc_mn_token, "z"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_Z; strcpy(mc_mn_Set_Vars_Coord_Label,"z [m]"); strcpy(mc_mn_Set_Vars_Coord_Var,"z"); mc_mn_lmin = mc_mn_Vars->mzmin; mc_mn_lmax = mc_mn_Vars->mzmax; }
if (!strcmp(mc_mn_token, "k") || !strcmp(mc_mn_token, "wavevector"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_K; strcpy(mc_mn_Set_Vars_Coord_Label,"|k| [Angs-1]"); strcpy(mc_mn_Set_Vars_Coord_Var,"k"); mc_mn_lmin = 0; mc_mn_lmax = 10; }
if (!strcmp(mc_mn_token, "v"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_V; strcpy(mc_mn_Set_Vars_Coord_Label,"Velocity [m/s]"); strcpy(mc_mn_Set_Vars_Coord_Var,"v"); mc_mn_lmin = 0; mc_mn_lmax = 10000; }
if (!strcmp(mc_mn_token, "t") || !strcmp(mc_mn_token, "time"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_T; strcpy(mc_mn_Set_Vars_Coord_Label,"TOF [s]"); strcpy(mc_mn_Set_Vars_Coord_Var,"t"); mc_mn_lmin = 0; mc_mn_lmax = .1; }
if ((!strcmp(mc_mn_token, "p") || !strcmp(mc_mn_token, "intensity") || !strcmp(mc_mn_token, "flux")))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_P;
if (mc_mn_Vars->Flag_per_cm2) strcpy(mc_mn_Set_Vars_Coord_Label,"Intensity [n/cm^2/s]");
else strcpy(mc_mn_Set_Vars_Coord_Label,"Intensity [n/s]");
strcpy(mc_mn_Set_Vars_Coord_Var,"I");
mc_mn_lmin = 0; mc_mn_lmax = FLT_MAX; }
if (!strcmp(mc_mn_token, "vx"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_VX; strcpy(mc_mn_Set_Vars_Coord_Label,"vx [m/s]"); strcpy(mc_mn_Set_Vars_Coord_Var,"vx"); mc_mn_lmin = -1000; mc_mn_lmax = 1000; }
if (!strcmp(mc_mn_token, "vy"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_VY; strcpy(mc_mn_Set_Vars_Coord_Label,"vy [m/s]"); strcpy(mc_mn_Set_Vars_Coord_Var,"vy"); mc_mn_lmin = -1000; mc_mn_lmax = 1000; }
if (!strcmp(mc_mn_token, "vz"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_VZ; strcpy(mc_mn_Set_Vars_Coord_Label,"vz [m/s]"); strcpy(mc_mn_Set_Vars_Coord_Var,"vz"); mc_mn_lmin = -10000; mc_mn_lmax = 10000; }
if (!strcmp(mc_mn_token, "kx"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_KX; strcpy(mc_mn_Set_Vars_Coord_Label,"kx [Angs-1]"); strcpy(mc_mn_Set_Vars_Coord_Var,"kx"); mc_mn_lmin = -1; mc_mn_lmax = 1; }
if (!strcmp(mc_mn_token, "ky"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_KY; strcpy(mc_mn_Set_Vars_Coord_Label,"ky [Angs-1]"); strcpy(mc_mn_Set_Vars_Coord_Var,"ky"); mc_mn_lmin = -1; mc_mn_lmax = 1; }
if (!strcmp(mc_mn_token, "kz"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_KZ; strcpy(mc_mn_Set_Vars_Coord_Label,"kz [Angs-1]"); strcpy(mc_mn_Set_Vars_Coord_Var,"kz"); mc_mn_lmin = -10; mc_mn_lmax = 10; }
if (!strcmp(mc_mn_token, "sx"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_SX; strcpy(mc_mn_Set_Vars_Coord_Label,"sx [1]"); strcpy(mc_mn_Set_Vars_Coord_Var,"sx"); mc_mn_lmin = -1; mc_mn_lmax = 1; }
if (!strcmp(mc_mn_token, "sy"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_SY; strcpy(mc_mn_Set_Vars_Coord_Label,"sy [1]"); strcpy(mc_mn_Set_Vars_Coord_Var,"sy"); mc_mn_lmin = -1; mc_mn_lmax = 1; }
if (!strcmp(mc_mn_token, "sz"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_SZ; strcpy(mc_mn_Set_Vars_Coord_Label,"sz [1]"); strcpy(mc_mn_Set_Vars_Coord_Var,"sz"); mc_mn_lmin = -1; mc_mn_lmax = 1; }
if (!strcmp(mc_mn_token, "energy") || !strcmp(mc_mn_token, "omega"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_ENERGY; strcpy(mc_mn_Set_Vars_Coord_Label,"Energy [meV]"); strcpy(mc_mn_Set_Vars_Coord_Var,"E"); mc_mn_lmin = 0; mc_mn_lmax = 100; }
if (!strcmp(mc_mn_token, "lambda") || !strcmp(mc_mn_token, "wavelength"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_LAMBDA; strcpy(mc_mn_Set_Vars_Coord_Label,"Wavelength [Angs]"); strcpy(mc_mn_Set_Vars_Coord_Var,"L"); mc_mn_lmin = 0; mc_mn_lmax = 100; }
if (!strcmp(mc_mn_token, "radius") || !strcmp(mc_mn_token, "xy"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_RADIUS; strcpy(mc_mn_Set_Vars_Coord_Label,"Radius [m]"); strcpy(mc_mn_Set_Vars_Coord_Var,"R"); mc_mn_lmin = 0; mc_mn_lmax = mc_mn_xmax; }
if (!strcmp(mc_mn_token, "vxy"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_VXY; strcpy(mc_mn_Set_Vars_Coord_Label,"Radial Velocity [m]"); strcpy(mc_mn_Set_Vars_Coord_Var,"Vxy"); mc_mn_lmin = 0; mc_mn_lmax = 2000; }
if (!strcmp(mc_mn_token, "kxy"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_KXY; strcpy(mc_mn_Set_Vars_Coord_Label,"Radial Wavevector [Angs-1]"); strcpy(mc_mn_Set_Vars_Coord_Var,"Kxy"); mc_mn_lmin = 0; mc_mn_lmax = 2; }
if (!strcmp(mc_mn_token, "angle"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_ANGLE; strcpy(mc_mn_Set_Vars_Coord_Label,"Angle [deg]"); strcpy(mc_mn_Set_Vars_Coord_Var,"A"); mc_mn_lmin = -5; mc_mn_lmax = 5; }
if (!strcmp(mc_mn_token, "hdiv")|| !strcmp(mc_mn_token, "divergence") || !strcmp(mc_mn_token, "xdiv") || !strcmp(mc_mn_token, "dx"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_HDIV; strcpy(mc_mn_Set_Vars_Coord_Label,"Hor. Divergence [deg]"); strcpy(mc_mn_Set_Vars_Coord_Var,"HD"); mc_mn_lmin = -5; mc_mn_lmax = 5; }
if (!strcmp(mc_mn_token, "vdiv") || !strcmp(mc_mn_token, "ydiv") || !strcmp(mc_mn_token, "dy"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_VDIV; strcpy(mc_mn_Set_Vars_Coord_Label,"Vert. Divergence [deg]"); strcpy(mc_mn_Set_Vars_Coord_Var,"VD"); mc_mn_lmin = -5; mc_mn_lmax = 5; }
if (!strcmp(mc_mn_token, "theta") || !strcmp(mc_mn_token, "longitude"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_THETA; strcpy(mc_mn_Set_Vars_Coord_Label,"Longitude [deg]"); strcpy(mc_mn_Set_Vars_Coord_Var,"th"); mc_mn_lmin = -180; mc_mn_lmax = 180; }
if (!strcmp(mc_mn_token, "phi") || !strcmp(mc_mn_token, "lattitude"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_PHI; strcpy(mc_mn_Set_Vars_Coord_Label,"Lattitude [deg]"); strcpy(mc_mn_Set_Vars_Coord_Var,"ph"); mc_mn_lmin = -180; mc_mn_lmax = 180; }
if (!strcmp(mc_mn_token, "ncounts"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_NCOUNT; strcpy(mc_mn_Set_Vars_Coord_Label,"Neutrons [1]"); strcpy(mc_mn_Set_Vars_Coord_Var,"N"); mc_mn_lmin = 0; mc_mn_lmax = 1e10; }
if (!strcmp(mc_mn_token, "user") || !strcmp(mc_mn_token, "user1"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_USER1; strncpy(mc_mn_Set_Vars_Coord_Label,mc_mn_Vars->UserName1,32); strcpy(mc_mn_Set_Vars_Coord_Var,"U1"); mc_mn_lmin = -1e10; mc_mn_lmax = 1e10; }
if (!strcmp(mc_mn_token, "user2"))
{ mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_USER2; strncpy(mc_mn_Set_Vars_Coord_Label,mc_mn_Vars->UserName2,32); strcpy(mc_mn_Set_Vars_Coord_Var,"U2"); mc_mn_lmin = -1e10; mc_mn_lmax = 1e10; }
/* now stores variable keywords detected, if any */
if (mc_mn_Set_Vars_Coord_Type != mc_mn_DEFS->COORD_NONE)
{
int mc_mn_Coord_Number = mc_mn_Vars->Coord_Number;
if (mc_mn_Vars->Flag_log) { mc_mn_Set_Vars_Coord_Type |= mc_mn_DEFS->COORD_LOG; mc_mn_Vars->Flag_log = 0; }
if (mc_mn_Flag_abs) { mc_mn_Set_Vars_Coord_Type |= mc_mn_DEFS->COORD_ABS; mc_mn_Flag_abs = 0; }
if (mc_mn_Flag_auto != 0) { mc_mn_Set_Vars_Coord_Type |= mc_mn_DEFS->COORD_AUTO; mc_mn_Flag_auto = 0; }
if (mc_mn_Set_Coord_Mode == mc_mn_DEFS->COORD_SIGNAL)
{
mc_mn_Coord_Number = 0;
mc_mn_Vars->Flag_signal = mc_mn_Set_Vars_Coord_Type;
}
else
{
if (mc_mn_Coord_Number < MONnD_COORD_NMAX)
{ mc_mn_Coord_Number++;
mc_mn_Vars->Coord_Number = mc_mn_Coord_Number; }
else if (mc_mn_Vars->Flag_Verbose) printf("Monitor_nD: %s reached max number of variables (%i).\n", mc_mn_Vars->compcurname, MONnD_COORD_NMAX);
}
mc_mn_Vars->Coord_Type[mc_mn_Coord_Number] = mc_mn_Set_Vars_Coord_Type;
strncpy(mc_mn_Vars->Coord_Label[mc_mn_Coord_Number], mc_mn_Set_Vars_Coord_Label,30);
strncpy(mc_mn_Vars->Coord_Var[mc_mn_Coord_Number], mc_mn_Set_Vars_Coord_Var,30);
if (mc_mn_lmin > mc_mn_lmax) { mc_mn_XY = mc_mn_lmin; mc_mn_lmin=mc_mn_lmax; mc_mn_lmax = mc_mn_XY; }
mc_mn_Vars->Coord_Min[mc_mn_Coord_Number] = mc_mn_lmin;
mc_mn_Vars->Coord_Max[mc_mn_Coord_Number] = mc_mn_lmax;
if (mc_mn_Set_Coord_Mode != mc_mn_DEFS->COORD_SIGNAL) mc_mn_Vars->Coord_Bin[mc_mn_Coord_Number] = 20;
mc_mn_Set_Coord_Mode = mc_mn_DEFS->COORD_VAR;
mc_mn_Flag_All = 0;
mc_mn_Flag_No = 0;
} else {
/* no variable name could be read from options */
if (!mc_mn_iskeyword) {
if (strcmp(mc_mn_token, "cm2") && strcmp(mc_mn_token, "incoming")
&& strcmp(mc_mn_token, "outgoing") && strcmp(mc_mn_token, "cm2")
&& strcmp(mc_mn_token, "cm^2") && strcmp(mc_mn_token, "float")
&& strcmp(mc_mn_token, "double") && strcmp(mc_mn_token, "binary"))
printf("Monitor_nD: %s: unknown '%s' keyword in 'options'. Ignoring.\n", mc_mn_Vars->compcurname, mc_mn_token);
}
}
mc_mn_carg++;
} /* end if mc_mn_token */
} /* end while mc_mn_carg */
free(mc_mn_option_copy);
if (mc_mn_carg == 128) printf("Monitor_nD: %s reached max number of mc_mn_tokens (%i). Skipping.\n", mc_mn_Vars->compcurname, 128);
if ((mc_mn_Vars->Flag_Shape == mc_mn_DEFS->SHAPE_BOX) && (fabs(mc_mn_Vars->mzmax - mc_mn_Vars->mzmin) == 0)) mc_mn_Vars->Flag_Shape = mc_mn_DEFS->SHAPE_SQUARE;
if (mc_mn_Vars->Flag_log == 1) mc_mn_Vars->Coord_Type[0] |= mc_mn_DEFS->COORD_LOG;
if (mc_mn_Vars->Coord_Number == 0)
{ mc_mn_Vars->Flag_Auto_Limits=0; mc_mn_Vars->Flag_Multiple=0; mc_mn_Vars->Flag_List=0; }
/* now setting Monitor Name from variable mc_mn_labels */
strcpy(mc_mn_Vars->Monitor_Label,"");
mc_mn_XY = 1; /* will contain total bin number */
for (mc_mn_i = 0; mc_mn_i <= mc_mn_Vars->Coord_Number; mc_mn_i++)
{
if (mc_mn_Flag_auto != 0) mc_mn_Vars->Coord_Type[mc_mn_i] |= mc_mn_DEFS->COORD_AUTO;
mc_mn_Set_Vars_Coord_Type = (mc_mn_Vars->Coord_Type[mc_mn_i] & 31);
if ((mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_THETA)
|| (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_PHI)
|| (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_X)
|| (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_Y)
|| (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_Z)
|| (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_RADIUS))
strcpy(mc_mn_Short_Label[mc_mn_i],"Position");
else
if ((mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_VX)
|| (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_VY)
|| (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_VZ)
|| (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_V)
|| (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_VXY))
strcpy(mc_mn_Short_Label[mc_mn_i],"Velocity");
else
if ((mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_KX)
|| (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_KY)
|| (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_KZ)
|| (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_KXY)
|| (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_K))
strcpy(mc_mn_Short_Label[mc_mn_i],"Wavevector");
else
if ((mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_SX)
|| (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_SY)
|| (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_SZ))
strcpy(mc_mn_Short_Label[mc_mn_i],"Spin");
else
if ((mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_HDIV)
|| (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_VDIV)
|| (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_ANGLE))
strcpy(mc_mn_Short_Label[mc_mn_i],"Divergence");
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_ENERGY)
strcpy(mc_mn_Short_Label[mc_mn_i],"Energy");
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_LAMBDA)
strcpy(mc_mn_Short_Label[mc_mn_i],"Wavelength");
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_NCOUNT)
strcpy(mc_mn_Short_Label[mc_mn_i],"Neutron counts");
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_T)
strcpy(mc_mn_Short_Label[mc_mn_i],"Time Of Flight");
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_P)
strcpy(mc_mn_Short_Label[mc_mn_i],"Intensity");
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_USER1)
strncpy(mc_mn_Short_Label[mc_mn_i],mc_mn_Vars->UserName1,32);
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_USER2)
strncpy(mc_mn_Short_Label[mc_mn_i],mc_mn_Vars->UserName2,32);
else
strcpy(mc_mn_Short_Label[mc_mn_i],"Unknown");
if (mc_mn_Vars->Coord_Type[mc_mn_i] & mc_mn_DEFS->COORD_ABS)
{ strcat(mc_mn_Vars->Coord_Label[mc_mn_i]," (abs)"); }
if (mc_mn_Vars->Coord_Type[mc_mn_i] & mc_mn_DEFS->COORD_LOG)
{ strcat(mc_mn_Vars->Coord_Label[mc_mn_i]," (log)"); }
strcat(mc_mn_Vars->Monitor_Label, " ");
strcat(mc_mn_Vars->Monitor_Label, mc_mn_Short_Label[mc_mn_i]);
mc_mn_XY *= mc_mn_Vars->Coord_Bin[mc_mn_i];
} /* end for mc_mn_Short_Label */
/* update label 'signal per bin' if more than 1 bin */
if (mc_mn_XY > 1 && mc_mn_Vars->Coord_Number) {
strncat(mc_mn_Vars->Coord_Label[0], " per bin", 30);
if (mc_mn_Vars->Flag_capture)
printf("Monitor_nD: %s: Using capture flux weightening on %ld bins.\n"
" Use binned data with caution, and prefer monitor integral value (I,Ierr).\n", mc_mn_Vars->compcurname, (long)mc_mn_XY);
}
strcat(mc_mn_Vars->Monitor_Label, " Monitor");
if (mc_mn_Vars->Flag_Shape == mc_mn_DEFS->SHAPE_SQUARE) strcat(mc_mn_Vars->Monitor_Label, " (Square)");
if (mc_mn_Vars->Flag_Shape == mc_mn_DEFS->SHAPE_DISK) strcat(mc_mn_Vars->Monitor_Label, " (Disk)");
if (mc_mn_Vars->Flag_Shape == mc_mn_DEFS->SHAPE_SPHERE) strcat(mc_mn_Vars->Monitor_Label, " (Sphere)");
if (mc_mn_Vars->Flag_Shape == mc_mn_DEFS->SHAPE_CYLIND) strcat(mc_mn_Vars->Monitor_Label, " (Cylinder)");
if (mc_mn_Vars->Flag_Shape == mc_mn_DEFS->SHAPE_BANANA) strcat(mc_mn_Vars->Monitor_Label, " (Banana)");
if (mc_mn_Vars->Flag_Shape == mc_mn_DEFS->SHAPE_BOX) strcat(mc_mn_Vars->Monitor_Label, " (Box)");
if ((mc_mn_Vars->Flag_Shape == mc_mn_DEFS->SHAPE_CYLIND) || (mc_mn_Vars->Flag_Shape == mc_mn_DEFS->SHAPE_BANANA) || (mc_mn_Vars->Flag_Shape == mc_mn_DEFS->SHAPE_SPHERE) || (mc_mn_Vars->Flag_Shape == mc_mn_DEFS->SHAPE_BOX))
{
if (strstr(mc_mn_Vars->option, "incoming"))
{
mc_mn_Vars->Flag_Shape = abs(mc_mn_Vars->Flag_Shape);
strcat(mc_mn_Vars->Monitor_Label, " [in]");
}
else /* if strstr(mc_mn_Vars->option, "outgoing")) */
{
mc_mn_Vars->Flag_Shape = -abs(mc_mn_Vars->Flag_Shape);
strcat(mc_mn_Vars->Monitor_Label, " [out]");
}
}
if (mc_mn_Vars->Flag_UsePreMonitor == 1)
{
strcat(mc_mn_Vars->Monitor_Label, " at ");
strncat(mc_mn_Vars->Monitor_Label, mc_mn_Vars->UserName1,32);
}
if (mc_mn_Vars->Flag_log == 1) strcat(mc_mn_Vars->Monitor_Label, " [log] ");
/* mc_mn_Vars->Coord_Number 0 : intensity or signal
* mc_mn_Vars->Coord_Number 1:n : detector variables */
/* now allocate memory to store variables in TRACE */
if ((mc_mn_Vars->Coord_Number != 2) && !mc_mn_Vars->Flag_Multiple && !mc_mn_Vars->Flag_List)
{ mc_mn_Vars->Flag_Multiple = 1; mc_mn_Vars->Flag_List = 0; } /* default is n1D */
/* list and auto limits case : mc_mn_Vars->Flag_List or mc_mn_Vars->Flag_Auto_Limits
* -> Buffer to flush and suppress after mc_mn_Vars->Flag_Auto_Limits
*/
if ((mc_mn_Vars->Flag_Auto_Limits || mc_mn_Vars->Flag_List) && mc_mn_Vars->Coord_Number)
{ /* Dim : (mc_mn_Vars->Coord_Number+1)*mc_mn_Vars->Buffer_Block matrix (for p, dp) */
mc_mn_Vars->Mon2D_Buffer = (double *)malloc((mc_mn_Vars->Coord_Number+1)*mc_mn_Vars->Buffer_Block*sizeof(double));
if (mc_mn_Vars->Mon2D_Buffer == NULL)
{ printf("Monitor_nD: %s cannot allocate mc_mn_Vars->Mon2D_Buffer (%li). No list and auto limits.\n", mc_mn_Vars->compcurname, mc_mn_Vars->Buffer_Block*(mc_mn_Vars->Coord_Number+1)*sizeof(double)); mc_mn_Vars->Flag_List = 0; mc_mn_Vars->Flag_Auto_Limits = 0; }
else
{
for (mc_mn_i=0; mc_mn_i < (mc_mn_Vars->Coord_Number+1)*mc_mn_Vars->Buffer_Block; mc_mn_Vars->Mon2D_Buffer[mc_mn_i++] = (double)0);
}
mc_mn_Vars->Buffer_Size = mc_mn_Vars->Buffer_Block;
}
/* 1D and n1D case : mc_mn_Vars->Flag_Multiple */
if (mc_mn_Vars->Flag_Multiple && mc_mn_Vars->Coord_Number)
{ /* Dim : mc_mn_Vars->Coord_Number*mc_mn_Vars->Coord_Bin[mc_mn_i] vectors */
mc_mn_Vars->Mon2D_N = (double **)malloc((mc_mn_Vars->Coord_Number)*sizeof(double *));
mc_mn_Vars->Mon2D_p = (double **)malloc((mc_mn_Vars->Coord_Number)*sizeof(double *));
mc_mn_Vars->Mon2D_p2 = (double **)malloc((mc_mn_Vars->Coord_Number)*sizeof(double *));
if ((mc_mn_Vars->Mon2D_N == NULL) || (mc_mn_Vars->Mon2D_p == NULL) || (mc_mn_Vars->Mon2D_p2 == NULL))
{ fprintf(stderr,"Monitor_nD: %s n1D cannot allocate mc_mn_Vars->Mon2D_N/p/2p (%li). Fatal.\n", mc_mn_Vars->compcurname, (mc_mn_Vars->Coord_Number)*sizeof(double *)); exit(-1); }
for (mc_mn_i= 1; mc_mn_i <= mc_mn_Vars->Coord_Number; mc_mn_i++)
{
mc_mn_Vars->Mon2D_N[mc_mn_i-1] = (double *)malloc(mc_mn_Vars->Coord_Bin[mc_mn_i]*sizeof(double));
mc_mn_Vars->Mon2D_p[mc_mn_i-1] = (double *)malloc(mc_mn_Vars->Coord_Bin[mc_mn_i]*sizeof(double));
mc_mn_Vars->Mon2D_p2[mc_mn_i-1] = (double *)malloc(mc_mn_Vars->Coord_Bin[mc_mn_i]*sizeof(double));
if ((mc_mn_Vars->Mon2D_N == NULL) || (mc_mn_Vars->Mon2D_p == NULL) || (mc_mn_Vars->Mon2D_p2 == NULL))
{ fprintf(stderr,"Monitor_nD: %s n1D cannot allocate %s mc_mn_Vars->Mon2D_N/p/2p[%li] (%li). Fatal.\n", mc_mn_Vars->compcurname, mc_mn_Vars->Coord_Var[mc_mn_i], mc_mn_i, (mc_mn_Vars->Coord_Bin[mc_mn_i])*sizeof(double *)); exit(-1); }
else
{
for (mc_mn_j=0; mc_mn_j < mc_mn_Vars->Coord_Bin[mc_mn_i]; mc_mn_j++ )
{ mc_mn_Vars->Mon2D_N[mc_mn_i-1][mc_mn_j] = (double)0; mc_mn_Vars->Mon2D_p[mc_mn_i-1][mc_mn_j] = (double)0; mc_mn_Vars->Mon2D_p2[mc_mn_i-1][mc_mn_j] = (double)0; }
}
}
}
else /* 2D case : mc_mn_Vars->Coord_Number==2 and !mc_mn_Vars->Flag_Multiple and !mc_mn_Vars->Flag_List */
if ((mc_mn_Vars->Coord_Number == 2) && !mc_mn_Vars->Flag_Multiple)
{ /* Dim : mc_mn_Vars->Coord_Bin[1]*mc_mn_Vars->Coord_Bin[2] matrix */
mc_mn_Vars->Mon2D_N = (double **)malloc((mc_mn_Vars->Coord_Bin[1])*sizeof(double *));
mc_mn_Vars->Mon2D_p = (double **)malloc((mc_mn_Vars->Coord_Bin[1])*sizeof(double *));
mc_mn_Vars->Mon2D_p2 = (double **)malloc((mc_mn_Vars->Coord_Bin[1])*sizeof(double *));
if ((mc_mn_Vars->Mon2D_N == NULL) || (mc_mn_Vars->Mon2D_p == NULL) || (mc_mn_Vars->Mon2D_p2 == NULL))
{ fprintf(stderr,"Monitor_nD: %s 2D cannot allocate %s mc_mn_Vars->Mon2D_N/p/2p (%li). Fatal.\n", mc_mn_Vars->compcurname, mc_mn_Vars->Coord_Var[1], (mc_mn_Vars->Coord_Bin[1])*sizeof(double *)); exit(-1); }
for (mc_mn_i= 0; mc_mn_i < mc_mn_Vars->Coord_Bin[1]; mc_mn_i++)
{
mc_mn_Vars->Mon2D_N[mc_mn_i] = (double *)malloc(mc_mn_Vars->Coord_Bin[2]*sizeof(double));
mc_mn_Vars->Mon2D_p[mc_mn_i] = (double *)malloc(mc_mn_Vars->Coord_Bin[2]*sizeof(double));
mc_mn_Vars->Mon2D_p2[mc_mn_i] = (double *)malloc(mc_mn_Vars->Coord_Bin[2]*sizeof(double));
if ((mc_mn_Vars->Mon2D_N == NULL) || (mc_mn_Vars->Mon2D_p == NULL) || (mc_mn_Vars->Mon2D_p2 == NULL))
{ fprintf(stderr,"Monitor_nD: %s 2D cannot allocate %s mc_mn_Vars->Mon2D_N/p/2p[%li] (%li). Fatal.\n", mc_mn_Vars->compcurname, mc_mn_Vars->Coord_Var[1], mc_mn_i, (mc_mn_Vars->Coord_Bin[2])*sizeof(double *)); exit(-1); }
else
{
for (mc_mn_j=0; mc_mn_j < mc_mn_Vars->Coord_Bin[2]; mc_mn_j++ )
{ mc_mn_Vars->Mon2D_N[mc_mn_i][mc_mn_j] = (double)0; mc_mn_Vars->Mon2D_p[mc_mn_i][mc_mn_j] = (double)0; mc_mn_Vars->Mon2D_p2[mc_mn_i][mc_mn_j] = (double)0; }
}
}
}
/* no Mon2D allocated for
* (mc_mn_Vars->Coord_Number != 2) && !mc_mn_Vars->Flag_Multiple && mc_mn_Vars->Flag_List */
mc_mn_Vars->psum = 0;
mc_mn_Vars->p2sum = 0;
mc_mn_Vars->Nsum = 0;
mc_mn_Vars->area = fabs(mc_mn_Vars->mxmax - mc_mn_Vars->mxmin)*fabs(mc_mn_Vars->mymax - mc_mn_Vars->mymin)*1E4; /* in cm**2 for square and box shapes */
mc_mn_Vars->Sphere_Radius = fabs(mc_mn_Vars->mxmax - mc_mn_Vars->mxmin)/2;
if ((abs(mc_mn_Vars->Flag_Shape) == mc_mn_DEFS->SHAPE_DISK) || (abs(mc_mn_Vars->Flag_Shape) == mc_mn_DEFS->SHAPE_SPHERE))
{
mc_mn_Vars->area = PI*mc_mn_Vars->Sphere_Radius*mc_mn_Vars->Sphere_Radius; /* disk shapes */
}
if (mc_mn_Vars->area == 0) mc_mn_Vars->Coord_Number = 0;
if (mc_mn_Vars->Coord_Number == 0 && mc_mn_Vars->Flag_Verbose) printf("Monitor_nD: %s is unactivated (0D)\n", mc_mn_Vars->compcurname);
mc_mn_Vars->Cylinder_Height = fabs(mc_mn_Vars->mymax - mc_mn_Vars->mymin);
if (mc_mn_Vars->Intermediate < 0) mc_mn_Vars->Intermediate = 0;
if (mc_mn_Vars->Intermediate > 1) mc_mn_Vars->Intermediate /= 100;
mc_mn_Vars->IntermediateCnts = mc_mn_Vars->Intermediate*mcget_ncount();
if (mc_mn_Vars->Flag_Verbose)
{
printf("Monitor_nD: %s is a %s.\n", mc_mn_Vars->compcurname, mc_mn_Vars->Monitor_Label);
printf("Monitor_nD: version %s with options=%s\n", MONITOR_ND_LIB_H, mc_mn_Vars->option);
}
} /* end Monitor_nD_Init */
/* ========================================================================= */
/* ADD: E.Farhi, Aug 6th, 2001: Monitor_nD section */
/* this routine is used to monitor one propagating neutron */
/* ========================================================================= */
double Monitor_nD_Trace(MonitornD_Defines_type *mc_mn_DEFS, MonitornD_Variables_type *mc_mn_Vars)
{
double mc_mn_XY=0;
long mc_mn_i,mc_mn_j;
double mc_mn_pp;
double mc_mn_Coord[MONnD_COORD_NMAX];
long mc_mn_Coord_Index[MONnD_COORD_NMAX];
char mc_mn_While_End =0;
long mc_mn_While_Buffer=0;
char mc_mn_Set_Vars_Coord_Type = mc_mn_DEFS->COORD_NONE;
/* mc_mn_Vars->Flag_Auto_Limits */
if ((mc_mn_Vars->Buffer_Counter >= mc_mn_Vars->Buffer_Block) && (mc_mn_Vars->Flag_Auto_Limits == 1) && (mc_mn_Vars->Coord_Number > 0))
{
/* auto limits case : get limits in Buffer for each variable */
/* Dim : (mc_mn_Vars->Coord_Number+1)*mc_mn_Vars->Buffer_Block matrix (for p, dp) */
if (mc_mn_Vars->Flag_Verbose) printf("Monitor_nD: %s getting %li Auto Limits from List (%li).\n", mc_mn_Vars->compcurname, mc_mn_Vars->Coord_Number, mc_mn_Vars->Buffer_Counter);
for (mc_mn_i = 1; mc_mn_i <= mc_mn_Vars->Coord_Number; mc_mn_i++)
{
if (mc_mn_Vars->Coord_Type[mc_mn_i] & mc_mn_DEFS->COORD_AUTO)
{
mc_mn_Vars->Coord_Min[mc_mn_i] = FLT_MAX;
mc_mn_Vars->Coord_Max[mc_mn_i] = -FLT_MAX;
for (mc_mn_j = 0; mc_mn_j < mc_mn_Vars->Buffer_Block; mc_mn_j++)
{
mc_mn_XY = mc_mn_Vars->Mon2D_Buffer[mc_mn_i+mc_mn_j*(mc_mn_Vars->Coord_Number+1)]; /* scanning variables in Buffer */
if (mc_mn_XY < mc_mn_Vars->Coord_Min[mc_mn_i]) mc_mn_Vars->Coord_Min[mc_mn_i] = mc_mn_XY;
if (mc_mn_XY > mc_mn_Vars->Coord_Max[mc_mn_i]) mc_mn_Vars->Coord_Max[mc_mn_i] = mc_mn_XY;
}
}
}
mc_mn_Vars->Flag_Auto_Limits = 2; /* pass to 2nd auto limits step */
}
/* manage realloc for list all if Buffer size exceeded */
if ((mc_mn_Vars->Buffer_Counter >= mc_mn_Vars->Buffer_Block) && (mc_mn_Vars->Flag_List >= 2))
{
if (mc_mn_Vars->Buffer_Size >= 20000 || mc_mn_Vars->Flag_List == 3)
{ /* save current (possibly append) and re-use Buffer */
Monitor_nD_Save(mc_mn_DEFS, mc_mn_Vars);
mc_mn_Vars->Flag_List = 3;
mc_mn_Vars->Buffer_Block = mc_mn_Vars->Buffer_Size;
mc_mn_Vars->Buffer_Counter = 0;
mc_mn_Vars->Neutron_Counter = 0;
}
else
{
mc_mn_Vars->Mon2D_Buffer = (double *)realloc(mc_mn_Vars->Mon2D_Buffer, (mc_mn_Vars->Coord_Number+1)*(mc_mn_Vars->Neutron_Counter+mc_mn_Vars->Buffer_Block)*sizeof(double));
if (mc_mn_Vars->Mon2D_Buffer == NULL)
{ printf("Monitor_nD: %s cannot reallocate mc_mn_Vars->Mon2D_Buffer[%li] (%li). Skipping.\n", mc_mn_Vars->compcurname, mc_mn_i, (mc_mn_Vars->Neutron_Counter+mc_mn_Vars->Buffer_Block)*sizeof(double)); mc_mn_Vars->Flag_List = 1; }
else { mc_mn_Vars->Buffer_Counter = 0; mc_mn_Vars->Buffer_Size = mc_mn_Vars->Neutron_Counter+mc_mn_Vars->Buffer_Block; }
}
}
while (!mc_mn_While_End)
{ /* we generate mc_mn_Coord[] and Coord_mc_mn_index[] from Buffer (auto limits) or passing neutron */
if ((mc_mn_Vars->Flag_Auto_Limits == 2) && (mc_mn_Vars->Coord_Number > 0))
{
if (mc_mn_While_Buffer < mc_mn_Vars->Buffer_Block)
{
/* first while loops (mc_mn_While_Buffer) */
/* auto limits case : scan Buffer within limits and store in Mon2D */
mc_mn_pp = mc_mn_Vars->Mon2D_Buffer[mc_mn_While_Buffer*(mc_mn_Vars->Coord_Number+1)];
mc_mn_Coord[0] = mc_mn_pp;
for (mc_mn_i = 1; mc_mn_i <= mc_mn_Vars->Coord_Number; mc_mn_i++)
{
/* scanning variables in Buffer */
mc_mn_XY = (mc_mn_Vars->Coord_Max[mc_mn_i]-mc_mn_Vars->Coord_Min[mc_mn_i]);
mc_mn_Coord[mc_mn_i] = mc_mn_Vars->Mon2D_Buffer[mc_mn_i+mc_mn_While_Buffer*(mc_mn_Vars->Coord_Number+1)];
if (mc_mn_XY > 0) mc_mn_Coord_Index[mc_mn_i] = floor((mc_mn_Coord[mc_mn_i]-mc_mn_Vars->Coord_Min[mc_mn_i])*mc_mn_Vars->Coord_Bin[mc_mn_i]/mc_mn_XY);
else mc_mn_Coord_Index[mc_mn_i] = 0;
if (mc_mn_Vars->Flag_With_Borders)
{
if (mc_mn_Coord_Index[mc_mn_i] < 0) mc_mn_Coord_Index[mc_mn_i] = 0;
if (mc_mn_Coord_Index[mc_mn_i] >= mc_mn_Vars->Coord_Bin[mc_mn_i]) mc_mn_Coord_Index[mc_mn_i] = mc_mn_Vars->Coord_Bin[mc_mn_i] - 1;
}
} /* end for */
mc_mn_While_Buffer++;
} /* end if in Buffer */
else /* (mc_mn_While_Buffer >= mc_mn_Vars->Buffer_Block) && (mc_mn_Vars->Flag_Auto_Limits == 2) */
{
mc_mn_Vars->Flag_Auto_Limits = 0;
if (!mc_mn_Vars->Flag_List) /* free Buffer not needed (no list to output) */
{ /* Dim : (mc_mn_Vars->Coord_Number+1)*mc_mn_Vars->Buffer_Block matrix (for p, dp) */
free(mc_mn_Vars->Mon2D_Buffer); mc_mn_Vars->Mon2D_Buffer = NULL;
}
}
}
else /* mc_mn_Vars->Flag_Auto_Limits == 0 or 1 */
{
for (mc_mn_i = 0; mc_mn_i <= mc_mn_Vars->Coord_Number; mc_mn_i++)
{ /* handle current neutron : last while */
mc_mn_XY = 0;
mc_mn_Set_Vars_Coord_Type = (mc_mn_Vars->Coord_Type[mc_mn_i] & 31);
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_X) mc_mn_XY = mc_mn_Vars->cx;
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_Y) mc_mn_XY = mc_mn_Vars->cy;
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_Z) mc_mn_XY = mc_mn_Vars->cz;
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_VX) mc_mn_XY = mc_mn_Vars->cvx;
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_VY) mc_mn_XY = mc_mn_Vars->cvy;
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_VZ) mc_mn_XY = mc_mn_Vars->cvz;
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_KX) mc_mn_XY = V2K*mc_mn_Vars->cvx;
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_KY) mc_mn_XY = V2K*mc_mn_Vars->cvy;
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_KZ) mc_mn_XY = V2K*mc_mn_Vars->cvz;
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_SX) mc_mn_XY = mc_mn_Vars->csx;
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_SY) mc_mn_XY = mc_mn_Vars->csy;
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_SZ) mc_mn_XY = mc_mn_Vars->csz;
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_T) mc_mn_XY = mc_mn_Vars->ct;
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_P) mc_mn_XY = mc_mn_Vars->cp;
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_HDIV) mc_mn_XY = RAD2DEG*atan2(mc_mn_Vars->cvx,mc_mn_Vars->cvz);
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_VDIV) mc_mn_XY = RAD2DEG*atan2(mc_mn_Vars->cvy,mc_mn_Vars->cvz);
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_V) mc_mn_XY = sqrt(mc_mn_Vars->cvx*mc_mn_Vars->cvx+mc_mn_Vars->cvy*mc_mn_Vars->cvy+mc_mn_Vars->cvz*mc_mn_Vars->cvz);
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_RADIUS) mc_mn_XY = sqrt(mc_mn_Vars->cx*mc_mn_Vars->cx+mc_mn_Vars->cy*mc_mn_Vars->cy);
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_VXY) mc_mn_XY = sqrt(mc_mn_Vars->cvx*mc_mn_Vars->cvx+mc_mn_Vars->cvy*mc_mn_Vars->cvy);
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_K) { mc_mn_XY = sqrt(mc_mn_Vars->cvx*mc_mn_Vars->cvx+mc_mn_Vars->cvy*mc_mn_Vars->cvy+mc_mn_Vars->cvz*mc_mn_Vars->cvz); mc_mn_XY *= V2K; }
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_KXY) { mc_mn_XY = sqrt(mc_mn_Vars->cvx*mc_mn_Vars->cvx+mc_mn_Vars->cvy*mc_mn_Vars->cvy); mc_mn_XY *= V2K; }
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_ENERGY) { mc_mn_XY = mc_mn_Vars->cvx*mc_mn_Vars->cvx+mc_mn_Vars->cvy*mc_mn_Vars->cvy+mc_mn_Vars->cvz*mc_mn_Vars->cvz; mc_mn_XY *= VS2E; }
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_LAMBDA) { mc_mn_XY = sqrt(mc_mn_Vars->cvx*mc_mn_Vars->cvx+mc_mn_Vars->cvy*mc_mn_Vars->cvy+mc_mn_Vars->cvz*mc_mn_Vars->cvz); mc_mn_XY *= V2K; if (mc_mn_XY != 0) mc_mn_XY = 2*PI/mc_mn_XY; }
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_NCOUNT) mc_mn_XY = mc_mn_Coord[mc_mn_i]+1;
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_ANGLE)
{ mc_mn_XY = sqrt(mc_mn_Vars->cvx*mc_mn_Vars->cvx+mc_mn_Vars->cvy*mc_mn_Vars->cvy+mc_mn_Vars->cvz*mc_mn_Vars->cvz);
if (mc_mn_Vars->cvz != 0)
{
mc_mn_XY= RAD2DEG*atan2(mc_mn_XY,mc_mn_Vars->cvz);
} else mc_mn_XY = 0;
}
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_THETA) { if (mc_mn_Vars->cz != 0) mc_mn_XY = RAD2DEG*atan2(mc_mn_Vars->cx,mc_mn_Vars->cz); }
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_PHI) { if (mc_mn_Vars->cz != 0) mc_mn_XY = RAD2DEG*atan2(sqrt(mc_mn_Vars->cx*mc_mn_Vars->cx+mc_mn_Vars->cy*mc_mn_Vars->cy),mc_mn_Vars->cz); }
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_USER1) mc_mn_XY = mc_mn_Vars->UserVariable1;
else
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_USER2) mc_mn_XY = mc_mn_Vars->UserVariable2;
else
mc_mn_XY = 0;
if (mc_mn_Vars->Coord_Type[mc_mn_i] & mc_mn_DEFS->COORD_ABS) mc_mn_XY=fabs(mc_mn_XY);
if (mc_mn_i && (mc_mn_Vars->Coord_Type[mc_mn_i] & mc_mn_DEFS->COORD_LOG)) /* not for the flux */
{ if (mc_mn_XY > 0) mc_mn_XY = log(mc_mn_XY)/log(10);
else mc_mn_XY = -100; }
mc_mn_Coord[mc_mn_i] = mc_mn_XY;
if (mc_mn_i == 0) { mc_mn_pp = mc_mn_XY; mc_mn_Coord_Index[mc_mn_i] = 0; }
else if (!mc_mn_Vars->Flag_Auto_Limits)
{
mc_mn_XY = (mc_mn_Vars->Coord_Max[mc_mn_i]-mc_mn_Vars->Coord_Min[mc_mn_i]);
if (mc_mn_XY > 0) mc_mn_Coord_Index[mc_mn_i] = floor((mc_mn_Coord[mc_mn_i]-mc_mn_Vars->Coord_Min[mc_mn_i])*mc_mn_Vars->Coord_Bin[mc_mn_i]/mc_mn_XY);
else mc_mn_Coord_Index[mc_mn_i] = 0;
if (mc_mn_Vars->Flag_With_Borders)
{
if (mc_mn_Coord_Index[mc_mn_i] < 0) mc_mn_Coord_Index[mc_mn_i] = 0;
if (mc_mn_Coord_Index[mc_mn_i] >= mc_mn_Vars->Coord_Bin[mc_mn_i]) mc_mn_Coord_Index[mc_mn_i] = mc_mn_Vars->Coord_Bin[mc_mn_i] - 1;
}
} /* else Auto_Limits will get Index later from Buffer */
} /* end for mc_mn_i */
mc_mn_While_End = 1;
} /* end else if mc_mn_Vars->Flag_Auto_Limits == 2 */
if (mc_mn_Vars->Flag_Auto_Limits != 2) /* not when reading auto limits Buffer */
{ /* now store Coord into Buffer (no mc_mn_index needed) if necessary */
if ((mc_mn_Vars->Buffer_Counter < mc_mn_Vars->Buffer_Block) && ((mc_mn_Vars->Flag_List) || (mc_mn_Vars->Flag_Auto_Limits == 1)))
{
for (mc_mn_i = 0; mc_mn_i <= mc_mn_Vars->Coord_Number; mc_mn_i++)
{
mc_mn_Vars->Mon2D_Buffer[mc_mn_i + mc_mn_Vars->Neutron_Counter*(mc_mn_Vars->Coord_Number+1)] = mc_mn_Coord[mc_mn_i];
}
mc_mn_Vars->Buffer_Counter++;
if (mc_mn_Vars->Flag_Verbose && (mc_mn_Vars->Buffer_Counter >= mc_mn_Vars->Buffer_Block) && (mc_mn_Vars->Flag_List == 1)) printf("Monitor_nD: %s %li neutrons stored in List.\n", mc_mn_Vars->compcurname, mc_mn_Vars->Buffer_Counter);
}
mc_mn_Vars->Neutron_Counter++;
} /* end (mc_mn_Vars->Flag_Auto_Limits != 2) */
/* store n1d/2d section for Buffer or current neutron in while */
if (mc_mn_Vars->Flag_Auto_Limits != 1) /* not when storing auto limits Buffer */
{
/* 1D and n1D case : mc_mn_Vars->Flag_Multiple */
if (mc_mn_Vars->Flag_Multiple)
{ /* Dim : mc_mn_Vars->Coord_Number*mc_mn_Vars->Coord_Bin[mc_mn_i] vectors (intensity is not included) */
/* check limits: monitors define a phase space to record */
char within_limits=1;
for (mc_mn_i= 1; mc_mn_i <= mc_mn_Vars->Coord_Number; mc_mn_i++)
{
mc_mn_j = mc_mn_Coord_Index[mc_mn_i];
if (mc_mn_j < 0 || mc_mn_j >= mc_mn_Vars->Coord_Bin[mc_mn_i])
within_limits=0;
}
if (within_limits)
{ for (mc_mn_i= 1; mc_mn_i <= mc_mn_Vars->Coord_Number; mc_mn_i++)
{
mc_mn_j = mc_mn_Coord_Index[mc_mn_i];
if (mc_mn_j >= 0 && mc_mn_j < mc_mn_Vars->Coord_Bin[mc_mn_i])
{
mc_mn_Vars->Mon2D_N[mc_mn_i-1][mc_mn_j]++;
mc_mn_Vars->Mon2D_p[mc_mn_i-1][mc_mn_j] += mc_mn_pp;
mc_mn_Vars->Mon2D_p2[mc_mn_i-1][mc_mn_j] += mc_mn_pp*mc_mn_pp;
}
}
}
else if (mc_mn_Vars->Flag_Exclusive)
{ mc_mn_pp = 0.0;
}
}
else /* 2D case : mc_mn_Vars->Coord_Number==2 and !mc_mn_Vars->Flag_Multiple and !mc_mn_Vars->Flag_List */
if ((mc_mn_Vars->Coord_Number == 2) && !mc_mn_Vars->Flag_Multiple)
{ /* Dim : mc_mn_Vars->Coord_Bin[1]*mc_mn_Vars->Coord_Bin[2] matrix */
mc_mn_i = mc_mn_Coord_Index[1];
mc_mn_j = mc_mn_Coord_Index[2];
if (mc_mn_i >= 0 && mc_mn_i < mc_mn_Vars->Coord_Bin[1] && mc_mn_j >= 0 && mc_mn_j < mc_mn_Vars->Coord_Bin[2])
{
mc_mn_Vars->Mon2D_N[mc_mn_i][mc_mn_j]++;
mc_mn_Vars->Mon2D_p[mc_mn_i][mc_mn_j] += mc_mn_pp;
mc_mn_Vars->Mon2D_p2[mc_mn_i][mc_mn_j] += mc_mn_pp*mc_mn_pp;
}
else if (mc_mn_Vars->Flag_Exclusive)
{ mc_mn_pp = 0.0;
}
}
} /* end (mc_mn_Vars->Flag_Auto_Limits != 1) */
} /* end while */
return mc_mn_pp;
} /* end Monitor_nD_Trace */
/* ========================================================================= */
/* ADD: E.Farhi, Aug 6th, 2001: Monitor_nD section */
/* this routine is used to save data files */
/* ========================================================================= */
void Monitor_nD_Save(MonitornD_Defines_type *mc_mn_DEFS, MonitornD_Variables_type *mc_mn_Vars)
{
char *mc_mn_fname;
long mc_mn_i,mc_mn_j;
double *mc_mn_p0m = NULL;
double *mc_mn_p1m = NULL;
double *mc_mn_p2m = NULL;
char mc_mn_Coord_X_Label[1024];
double mc_mn_min1d, mc_mn_max1d;
double mc_mn_min2d, mc_mn_max2d;
long mc_mn_bin1d, mc_mn_bin2d;
char mc_mn_While_End = 0;
long mc_mn_While_Buffer = 0;
double mc_mn_XY, mc_mn_pp;
double mc_mn_Coord[MONnD_COORD_NMAX];
long mc_mn_Coord_Index[MONnD_COORD_NMAX];
char mc_mn_label[1024];
double mc_mn_ratio;
mc_mn_ratio = 100*mcget_run_num()/mcget_ncount();
if (mc_mn_ratio < 99)
{
if (mc_mn_Vars->Flag_Verbose) printf("Monitor_nD: %s save intermediate results (%.2f %%).\n", mc_mn_Vars->compcurname, mc_mn_ratio);
}
/* check Buffer flush when end of simulation reached */
if ((mc_mn_Vars->Buffer_Counter <= mc_mn_Vars->Buffer_Block) && mc_mn_Vars->Flag_Auto_Limits && mc_mn_Vars->Mon2D_Buffer && mc_mn_Vars->Buffer_Counter)
{
/* Get Auto Limits */
if (mc_mn_Vars->Flag_Verbose) printf("Monitor_nD: %s getting %li Auto Limits from List (%li).\n", mc_mn_Vars->compcurname, mc_mn_Vars->Coord_Number, mc_mn_Vars->Buffer_Counter);
for (mc_mn_i = 1; mc_mn_i <= mc_mn_Vars->Coord_Number; mc_mn_i++)
{
if (mc_mn_Vars->Coord_Type[mc_mn_i] & mc_mn_DEFS->COORD_AUTO)
{
mc_mn_Vars->Coord_Min[mc_mn_i] = FLT_MAX;
mc_mn_Vars->Coord_Max[mc_mn_i] = -FLT_MAX;
for (mc_mn_j = 0; mc_mn_j < mc_mn_Vars->Buffer_Counter; mc_mn_j++)
{
mc_mn_XY = mc_mn_Vars->Mon2D_Buffer[mc_mn_i+mc_mn_j*(mc_mn_Vars->Coord_Number+1)]; /* scanning variables in Buffer */
if (mc_mn_XY < mc_mn_Vars->Coord_Min[mc_mn_i]) mc_mn_Vars->Coord_Min[mc_mn_i] = mc_mn_XY;
if (mc_mn_XY > mc_mn_Vars->Coord_Max[mc_mn_i]) mc_mn_Vars->Coord_Max[mc_mn_i] = mc_mn_XY;
}
}
}
mc_mn_Vars->Flag_Auto_Limits = 2; /* pass to 2nd auto limits step */
mc_mn_Vars->Buffer_Block = mc_mn_Vars->Buffer_Counter;
while (!mc_mn_While_End)
{ /* we generate mc_mn_Coord[] and Coord_mc_mn_index[] from Buffer (auto limits) or passing neutron */
if (mc_mn_While_Buffer < mc_mn_Vars->Buffer_Block)
{
/* first while loops (mc_mn_While_Buffer) */
mc_mn_Coord[0] = mc_mn_Vars->Mon2D_Buffer[mc_mn_While_Buffer*(mc_mn_Vars->Coord_Number+1)];
/* auto limits case : scan Buffer within limits and store in Mon2D */
for (mc_mn_i = 1; mc_mn_i <= mc_mn_Vars->Coord_Number; mc_mn_i++)
{
/* scanning variables in Buffer */
mc_mn_XY = (mc_mn_Vars->Coord_Max[mc_mn_i]-mc_mn_Vars->Coord_Min[mc_mn_i]);
mc_mn_Coord[mc_mn_i] = mc_mn_Vars->Mon2D_Buffer[mc_mn_i+mc_mn_While_Buffer*(mc_mn_Vars->Coord_Number+1)];
if (mc_mn_XY > 0) mc_mn_Coord_Index[mc_mn_i] = floor((mc_mn_Coord[mc_mn_i]-mc_mn_Vars->Coord_Min[mc_mn_i])*mc_mn_Vars->Coord_Bin[mc_mn_i]/mc_mn_XY);
else mc_mn_Coord_Index[mc_mn_i] = 0;
if (mc_mn_Vars->Flag_With_Borders)
{
if (mc_mn_Coord_Index[mc_mn_i] < 0) mc_mn_Coord_Index[mc_mn_i] = 0;
if (mc_mn_Coord_Index[mc_mn_i] >= mc_mn_Vars->Coord_Bin[mc_mn_i]) mc_mn_Coord_Index[mc_mn_i] = mc_mn_Vars->Coord_Bin[mc_mn_i] - 1;
}
} /* end for */
mc_mn_While_Buffer++;
} /* end if in Buffer */
else /* (mc_mn_While_Buffer >= mc_mn_Vars->Buffer_Block) && (mc_mn_Vars->Flag_Auto_Limits == 2) */
{
mc_mn_Vars->Flag_Auto_Limits = 0;
mc_mn_While_End = 1;
}
/* store n1d/2d section from Buffer */
mc_mn_pp = mc_mn_Coord[0];
/* 1D and n1D case : mc_mn_Vars->Flag_Multiple */
if (mc_mn_Vars->Flag_Multiple)
{ /* Dim : mc_mn_Vars->Coord_Number*mc_mn_Vars->Coord_Bin[mc_mn_i] vectors (intensity is not included) */
for (mc_mn_i= 0; mc_mn_i < mc_mn_Vars->Coord_Number; mc_mn_i++)
{
mc_mn_j = mc_mn_Coord_Index[mc_mn_i+1];
if (mc_mn_j >= 0 && mc_mn_j < mc_mn_Vars->Coord_Bin[mc_mn_i+1])
{
mc_mn_Vars->Mon2D_N[mc_mn_i][mc_mn_j]++;
mc_mn_Vars->Mon2D_p[mc_mn_i][mc_mn_j] += mc_mn_pp;
mc_mn_Vars->Mon2D_p2[mc_mn_i][mc_mn_j] += mc_mn_pp*mc_mn_pp;
}
}
}
else /* 2D case : mc_mn_Vars->Coord_Number==2 and !mc_mn_Vars->Flag_Multiple and !mc_mn_Vars->Flag_List */
if ((mc_mn_Vars->Coord_Number == 2) && !mc_mn_Vars->Flag_Multiple)
{ /* Dim : mc_mn_Vars->Coord_Bin[1]*mc_mn_Vars->Coord_Bin[2] matrix */
mc_mn_i = mc_mn_Coord_Index[1];
mc_mn_j = mc_mn_Coord_Index[2];
if (mc_mn_i >= 0 && mc_mn_i < mc_mn_Vars->Coord_Bin[1] && mc_mn_j >= 0 && mc_mn_j < mc_mn_Vars->Coord_Bin[2])
{
mc_mn_Vars->Mon2D_N[mc_mn_i][mc_mn_j]++;
mc_mn_Vars->Mon2D_p[mc_mn_i][mc_mn_j] += mc_mn_pp;
mc_mn_Vars->Mon2D_p2[mc_mn_i][mc_mn_j] += mc_mn_pp*mc_mn_pp;
}
} /* end store 2D/1D */
} /* end while */
} /* end Force Get Limits */
/* write output files (sent to file as p[i*n + j] vectors) */
if (mc_mn_Vars->Coord_Number == 0)
{
double mc_mn_Nsum;
double mc_mn_psum, mc_mn_p2sum;
mc_mn_Nsum = mc_mn_Vars->Nsum;
mc_mn_psum = mc_mn_Vars->psum;
mc_mn_p2sum= mc_mn_Vars->p2sum;
if (mc_mn_Vars->Flag_signal != mc_mn_DEFS->COORD_P && mc_mn_Nsum > 0)
{ mc_mn_psum /=mc_mn_Nsum; mc_mn_p2sum /= mc_mn_Nsum*mc_mn_Nsum; }
/* DETECTOR_OUT_0D(mc_mn_Vars->Monitor_Label, mc_mn_Vars->Nsum, mc_mn_Vars->psum, mc_mn_Vars->p2sum); */
mcdetector_out_0D(mc_mn_Vars->Monitor_Label, mc_mn_Nsum, mc_mn_psum, mc_mn_p2sum, mc_mn_Vars->compcurname, mc_mn_Vars->compcurpos);
}
else
if (strlen(mc_mn_Vars->Mon_File) > 0)
{
mc_mn_fname = (char*)malloc(strlen(mc_mn_Vars->Mon_File)+10*mc_mn_Vars->Coord_Number);
if (mc_mn_Vars->Flag_List && mc_mn_Vars->Mon2D_Buffer) /* List: DETECTOR_OUT_2D */
{
int ascii_only_orig;
char formatName[64];
char *formatName_orig;
if (mc_mn_Vars->Flag_List >= 2) mc_mn_Vars->Buffer_Size = mc_mn_Vars->Neutron_Counter;
if (mc_mn_Vars->Buffer_Size >= mc_mn_Vars->Neutron_Counter)
mc_mn_Vars->Buffer_Size = mc_mn_Vars->Neutron_Counter;
strcpy(mc_mn_fname,mc_mn_Vars->Mon_File);
if (strchr(mc_mn_Vars->Mon_File,'.') == NULL) strcat(mc_mn_fname, "_list");
mc_mn_min1d = 1; mc_mn_max1d = mc_mn_Vars->Coord_Number+1;
mc_mn_min2d = 0; mc_mn_max2d = mc_mn_Vars->Buffer_Size;
mc_mn_bin1d = mc_mn_Vars->Coord_Number+1; mc_mn_bin2d = mc_mn_Vars->Buffer_Size;
strcpy(mc_mn_Coord_X_Label,"");
for (mc_mn_i= 0; mc_mn_i <= mc_mn_Vars->Coord_Number; mc_mn_i++)
{
if (mc_mn_min2d < mc_mn_Vars->Coord_Min[mc_mn_i]) mc_mn_min2d = mc_mn_Vars->Coord_Min[mc_mn_i];
if (mc_mn_max2d < mc_mn_Vars->Coord_Max[mc_mn_i]) mc_mn_max2d = mc_mn_Vars->Coord_Max[mc_mn_i];
strcat(mc_mn_Coord_X_Label, mc_mn_Vars->Coord_Var[mc_mn_i]);
strcat(mc_mn_Coord_X_Label, " ");
if (strchr(mc_mn_Vars->Mon_File,'.') == NULL)
{ strcat(mc_mn_fname, "."); strcat(mc_mn_fname, mc_mn_Vars->Coord_Var[mc_mn_i]); }
}
if (mc_mn_Vars->Flag_Verbose) printf("Monitor_nD: %s write monitor file %s List (%lix%li).\n", mc_mn_Vars->compcurname, mc_mn_fname,mc_mn_bin2d,mc_mn_bin1d);
/* handle the type of list output */
ascii_only_orig = mcascii_only;
formatName_orig = mcformat.Name; /* copy the pointer position */
strcpy(formatName, mcformat.Name);
if (mc_mn_Vars->Flag_List >= 1)
{ /* Flag_List mode:
1=store 1 buffer
2=list all, triggers 3 when 1st buffer reallocated
3=re-used buffer (file already opened)
Format modifiers for Flag_List
1= normal monitor file (no modifier, export in one go)
2= write data+header, and footer if buffer not full (mc_mn_Vars->Buffer_Counter < mc_mn_Vars->Buffer_Block)
3= write data, and footer if buffer not full (final)
*/
strcat(formatName, " list ");
if (mc_mn_Vars->Flag_List == 3) strcat(formatName, " no header ");
if (mc_mn_Vars->Flag_List >= 2 && mc_mn_Vars->Buffer_Counter >= mc_mn_Vars->Buffer_Block)
strcat(formatName, " no footer ");
if (mc_mn_Vars->Flag_Binary_List) mcascii_only = 1;
if (mc_mn_Vars->Flag_Binary_List == 1)
strcat(formatName, " binary float ");
else if (mc_mn_Vars->Flag_Binary_List == 2)
strcat(formatName, " binary double ");
}
if (mc_mn_min2d == mc_mn_max2d) mc_mn_max2d = mc_mn_min2d+1e-6;
if (mc_mn_min1d == mc_mn_max1d) mc_mn_max1d = mc_mn_min1d+1e-6;
strcpy(mc_mn_label, mc_mn_Vars->Monitor_Label);
if (!mc_mn_Vars->Flag_Binary_List)
{ mc_mn_bin2d=-mc_mn_bin2d; }
mcformat.Name = formatName;
mcdetector_out_2D(
mc_mn_label,
"List of neutron events",
mc_mn_Coord_X_Label,
mc_mn_min2d, mc_mn_max2d,
mc_mn_min1d, mc_mn_max1d,
mc_mn_bin2d,
mc_mn_bin1d,
NULL,mc_mn_Vars->Mon2D_Buffer,NULL,
mc_mn_fname, mc_mn_Vars->compcurname, mc_mn_Vars->compcurpos);
/* reset the original type of output */
mcascii_only = ascii_only_orig;
mcformat.Name= formatName_orig;
}
if (mc_mn_Vars->Flag_Multiple) /* n1D: DETECTOR_OUT_1D */
{
for (mc_mn_i= 0; mc_mn_i < mc_mn_Vars->Coord_Number; mc_mn_i++)
{
strcpy(mc_mn_fname,mc_mn_Vars->Mon_File);
if (strchr(mc_mn_Vars->Mon_File,'.') == NULL)
{ strcat(mc_mn_fname, "."); strcat(mc_mn_fname, mc_mn_Vars->Coord_Var[mc_mn_i+1]); }
sprintf(mc_mn_Coord_X_Label, "%s monitor", mc_mn_Vars->Coord_Label[mc_mn_i+1]);
strcpy(mc_mn_label, mc_mn_Coord_X_Label);
if (mc_mn_Vars->Coord_Bin[mc_mn_i+1] > 0) { /* 1D monitor */
if (mc_mn_Vars->Flag_Verbose) printf("Monitor_nD: %s write monitor file %s 1D (%li).\n", mc_mn_Vars->compcurname, mc_mn_fname, mc_mn_Vars->Coord_Bin[mc_mn_i+1]);
mc_mn_min1d = mc_mn_Vars->Coord_Min[mc_mn_i+1];
mc_mn_max1d = mc_mn_Vars->Coord_Max[mc_mn_i+1];
if (mc_mn_min1d == mc_mn_max1d) mc_mn_max1d = mc_mn_min1d+1e-6;
mc_mn_p1m = (double *)malloc(mc_mn_Vars->Coord_Bin[mc_mn_i+1]*sizeof(double));
mc_mn_p2m = (double *)malloc(mc_mn_Vars->Coord_Bin[mc_mn_i+1]*sizeof(double));
if (mc_mn_p2m == NULL) /* use Raw Buffer line output */
{
if (mc_mn_Vars->Flag_Verbose) printf("Monitor_nD: %s cannot allocate memory for output. Using raw data.\n", mc_mn_Vars->compcurname);
if (mc_mn_p1m != NULL) free(mc_mn_p1m);
mcdetector_out_1D(
mc_mn_label,
mc_mn_Vars->Coord_Label[mc_mn_i+1],
mc_mn_Vars->Coord_Label[0],
mc_mn_Vars->Coord_Var[mc_mn_i+1],
mc_mn_min1d, mc_mn_max1d,
mc_mn_Vars->Coord_Bin[mc_mn_i+1],
mc_mn_Vars->Mon2D_N[mc_mn_i],mc_mn_Vars->Mon2D_p[mc_mn_i],mc_mn_Vars->Mon2D_p2[mc_mn_i],
mc_mn_fname, mc_mn_Vars->compcurname, mc_mn_Vars->compcurpos);
} /* if (mc_mn_p2m == NULL) */
else
{
if (mc_mn_Vars->Flag_log != 0)
{
mc_mn_XY = FLT_MAX;
for (mc_mn_j=0; mc_mn_j < mc_mn_Vars->Coord_Bin[mc_mn_i+1]; mc_mn_j++) /* search min of signal */
if ((mc_mn_XY > mc_mn_Vars->Mon2D_p[mc_mn_i][mc_mn_j]) && (mc_mn_Vars->Mon2D_p[mc_mn_i][mc_mn_j] > 0)) mc_mn_XY = mc_mn_Vars->Mon2D_p[mc_mn_i][mc_mn_j];
if (mc_mn_XY <= 0) mc_mn_XY = -log(FLT_MAX)/log(10); else mc_mn_XY = log(mc_mn_XY)/log(10)-1;
} /* if */
for (mc_mn_j=0; mc_mn_j < mc_mn_Vars->Coord_Bin[mc_mn_i+1]; mc_mn_j++)
{
mc_mn_p1m[mc_mn_j] = mc_mn_Vars->Mon2D_p[mc_mn_i][mc_mn_j];
mc_mn_p2m[mc_mn_j] = mc_mn_Vars->Mon2D_p2[mc_mn_i][mc_mn_j];
if (mc_mn_Vars->Flag_signal != mc_mn_DEFS->COORD_P && mc_mn_Vars->Mon2D_N[mc_mn_i][mc_mn_j] > 0)
{ /* normalize mean signal to the number of events */
mc_mn_p1m[mc_mn_j] /= mc_mn_Vars->Mon2D_N[mc_mn_i][mc_mn_j];
mc_mn_p2m[mc_mn_j] /= mc_mn_Vars->Mon2D_N[mc_mn_i][mc_mn_j]*mc_mn_Vars->Mon2D_N[mc_mn_i][mc_mn_j];
}
if (mc_mn_Vars->Flag_log != 0)
{
if ((mc_mn_p1m[mc_mn_j] > 0) && (mc_mn_p2m[mc_mn_j] > 0))
{
mc_mn_p2m[mc_mn_j] /= mc_mn_p1m[mc_mn_j]*mc_mn_p1m[mc_mn_j];
mc_mn_p1m[mc_mn_j] = log(mc_mn_p1m[mc_mn_j])/log(10);
}
else
{
mc_mn_p1m[mc_mn_j] = mc_mn_XY;
mc_mn_p2m[mc_mn_j] = 0;
}
}
} /* for */
mcdetector_out_1D(
mc_mn_label,
mc_mn_Vars->Coord_Label[mc_mn_i+1],
mc_mn_Vars->Coord_Label[0],
mc_mn_Vars->Coord_Var[mc_mn_i+1],
mc_mn_min1d, mc_mn_max1d,
mc_mn_Vars->Coord_Bin[mc_mn_i+1],
mc_mn_Vars->Mon2D_N[mc_mn_i],mc_mn_p1m,mc_mn_p2m,
mc_mn_fname, mc_mn_Vars->compcurname, mc_mn_Vars->compcurpos);
} /* else */
if (mc_mn_p1m != NULL) free(mc_mn_p1m); mc_mn_p1m=NULL;
if (mc_mn_p2m != NULL) free(mc_mn_p2m); mc_mn_p2m=NULL;
} else { /* 0d monitor */
mcdetector_out_0D(mc_mn_label, mc_mn_Vars->Mon2D_p[mc_mn_i][0], mc_mn_Vars->Mon2D_p2[mc_mn_i][0], mc_mn_Vars->Mon2D_N[mc_mn_i][0], mc_mn_Vars->compcurname, mc_mn_Vars->compcurpos);
}
} /* for */
} /* if 1D */
else
if (mc_mn_Vars->Coord_Number == 2) /* 2D: DETECTOR_OUT_2D */
{
strcpy(mc_mn_fname,mc_mn_Vars->Mon_File);
mc_mn_p0m = (double *)malloc(mc_mn_Vars->Coord_Bin[1]*mc_mn_Vars->Coord_Bin[2]*sizeof(double));
mc_mn_p1m = (double *)malloc(mc_mn_Vars->Coord_Bin[1]*mc_mn_Vars->Coord_Bin[2]*sizeof(double));
mc_mn_p2m = (double *)malloc(mc_mn_Vars->Coord_Bin[1]*mc_mn_Vars->Coord_Bin[2]*sizeof(double));
if (mc_mn_p2m == NULL)
{
if (mc_mn_Vars->Flag_Verbose) printf("Monitor_nD: %s cannot allocate memory for 2D array (%li). Skipping.\n", mc_mn_Vars->compcurname, 3*mc_mn_Vars->Coord_Bin[1]*mc_mn_Vars->Coord_Bin[2]*sizeof(double));
if (mc_mn_p0m != NULL) free(mc_mn_p0m);
if (mc_mn_p1m != NULL) free(mc_mn_p1m);
}
else
{
if (mc_mn_Vars->Flag_log != 0)
{
mc_mn_XY = FLT_MAX;
for (mc_mn_i= 0; mc_mn_i < mc_mn_Vars->Coord_Bin[1]; mc_mn_i++)
for (mc_mn_j= 0; mc_mn_j < mc_mn_Vars->Coord_Bin[2]; mc_mn_j++) /* search min of signal */
if ((mc_mn_XY > mc_mn_Vars->Mon2D_p[mc_mn_i][mc_mn_j]) && (mc_mn_Vars->Mon2D_p[mc_mn_i][mc_mn_j]>0)) mc_mn_XY = mc_mn_Vars->Mon2D_p[mc_mn_i][mc_mn_j];
if (mc_mn_XY <= 0) mc_mn_XY = -log(FLT_MAX)/log(10); else mc_mn_XY = log(mc_mn_XY)/log(10)-1;
}
for (mc_mn_i= 0; mc_mn_i < mc_mn_Vars->Coord_Bin[1]; mc_mn_i++)
{
for (mc_mn_j= 0; mc_mn_j < mc_mn_Vars->Coord_Bin[2]; mc_mn_j++)
{
long mc_mn_index;
mc_mn_index = mc_mn_j + mc_mn_i*mc_mn_Vars->Coord_Bin[2];
mc_mn_p0m[mc_mn_index] = mc_mn_Vars->Mon2D_N[mc_mn_i][mc_mn_j];
mc_mn_p1m[mc_mn_index] = mc_mn_Vars->Mon2D_p[mc_mn_i][mc_mn_j];
mc_mn_p2m[mc_mn_index] = mc_mn_Vars->Mon2D_p2[mc_mn_i][mc_mn_j];
if (mc_mn_Vars->Flag_signal != mc_mn_DEFS->COORD_P && mc_mn_p0m[mc_mn_index] > 0)
{
mc_mn_p1m[mc_mn_index] /= mc_mn_p0m[mc_mn_index];
mc_mn_p2m[mc_mn_index] /= mc_mn_p0m[mc_mn_index]*mc_mn_p0m[mc_mn_index];
}
if (mc_mn_Vars->Flag_log != 0)
{
if ((mc_mn_p1m[mc_mn_index] > 0) && (mc_mn_p2m[mc_mn_index] > 0))
{
mc_mn_p2m[mc_mn_index] /= (mc_mn_p1m[mc_mn_index]*mc_mn_p1m[mc_mn_index]);
mc_mn_p1m[mc_mn_index] = log(mc_mn_p1m[mc_mn_index])/log(10);
}
else
{
mc_mn_p1m[mc_mn_index] = mc_mn_XY;
mc_mn_p2m[mc_mn_index] = 0;
}
}
}
}
if (strchr(mc_mn_Vars->Mon_File,'.') == NULL)
{ strcat(mc_mn_fname, "."); strcat(mc_mn_fname, mc_mn_Vars->Coord_Var[1]);
strcat(mc_mn_fname, "_"); strcat(mc_mn_fname, mc_mn_Vars->Coord_Var[2]); }
if (mc_mn_Vars->Flag_Verbose) printf("Monitor_nD: %s write monitor file %s 2D (%lix%li).\n", mc_mn_Vars->compcurname, mc_mn_fname, mc_mn_Vars->Coord_Bin[1], mc_mn_Vars->Coord_Bin[2]);
mc_mn_min1d = mc_mn_Vars->Coord_Min[1];
mc_mn_max1d = mc_mn_Vars->Coord_Max[1];
if (mc_mn_min1d == mc_mn_max1d) mc_mn_max1d = mc_mn_min1d+1e-6;
mc_mn_min2d = mc_mn_Vars->Coord_Min[2];
mc_mn_max2d = mc_mn_Vars->Coord_Max[2];
if (mc_mn_min2d == mc_mn_max2d) mc_mn_max2d = mc_mn_min2d+1e-6;
strcpy(mc_mn_label, mc_mn_Vars->Monitor_Label);
if (mc_mn_Vars->Coord_Bin[1]*mc_mn_Vars->Coord_Bin[2] > 1
&& mc_mn_Vars->Flag_signal == mc_mn_DEFS->COORD_P)
strcat(mc_mn_label, " per bin");
mcdetector_out_2D(
mc_mn_label,
mc_mn_Vars->Coord_Label[1],
mc_mn_Vars->Coord_Label[2],
mc_mn_min1d, mc_mn_max1d,
mc_mn_min2d, mc_mn_max2d,
mc_mn_Vars->Coord_Bin[1],
mc_mn_Vars->Coord_Bin[2],
mc_mn_p0m,mc_mn_p1m,mc_mn_p2m,
mc_mn_fname, mc_mn_Vars->compcurname, mc_mn_Vars->compcurpos);
if (mc_mn_p0m != NULL) free(mc_mn_p0m);
if (mc_mn_p1m != NULL) free(mc_mn_p1m);
if (mc_mn_p2m != NULL) free(mc_mn_p2m);
}
}
free(mc_mn_fname);
}
} /* end Monitor_nD_Save */
/* ========================================================================= */
/* ADD: E.Farhi, Aug 6th, 2001: Monitor_nD section */
/* this routine is used to free memory */
/* ========================================================================= */
void Monitor_nD_Finally(MonitornD_Defines_type *mc_mn_DEFS,
MonitornD_Variables_type *mc_mn_Vars)
{
int mc_mn_i;
/* Now Free memory Mon2D.. */
if ((mc_mn_Vars->Flag_Auto_Limits || mc_mn_Vars->Flag_List) && mc_mn_Vars->Coord_Number)
{ /* Dim : (mc_mn_Vars->Coord_Number+1)*mc_mn_Vars->Buffer_Block matrix (for p, dp) */
if (mc_mn_Vars->Mon2D_Buffer != NULL) free(mc_mn_Vars->Mon2D_Buffer);
}
/* 1D and n1D case : mc_mn_Vars->Flag_Multiple */
if (mc_mn_Vars->Flag_Multiple && mc_mn_Vars->Coord_Number)
{ /* Dim : mc_mn_Vars->Coord_Number*mc_mn_Vars->Coord_Bin[mc_mn_i] vectors */
for (mc_mn_i= 0; mc_mn_i < mc_mn_Vars->Coord_Number; mc_mn_i++)
{
free(mc_mn_Vars->Mon2D_N[mc_mn_i]);
free(mc_mn_Vars->Mon2D_p[mc_mn_i]);
free(mc_mn_Vars->Mon2D_p2[mc_mn_i]);
}
free(mc_mn_Vars->Mon2D_N);
free(mc_mn_Vars->Mon2D_p);
free(mc_mn_Vars->Mon2D_p2);
}
/* 2D case : mc_mn_Vars->Coord_Number==2 and !mc_mn_Vars->Flag_Multiple and !mc_mn_Vars->Flag_List */
if ((mc_mn_Vars->Coord_Number == 2) && !mc_mn_Vars->Flag_Multiple)
{ /* Dim : mc_mn_Vars->Coord_Bin[1]*mc_mn_Vars->Coord_Bin[2] matrix */
for (mc_mn_i= 0; mc_mn_i < mc_mn_Vars->Coord_Bin[1]; mc_mn_i++)
{
free(mc_mn_Vars->Mon2D_N[mc_mn_i]);
free(mc_mn_Vars->Mon2D_p[mc_mn_i]);
free(mc_mn_Vars->Mon2D_p2[mc_mn_i]);
}
free(mc_mn_Vars->Mon2D_N);
free(mc_mn_Vars->Mon2D_p);
free(mc_mn_Vars->Mon2D_p2);
}
} /* end Monitor_nD_Finally */
/* ========================================================================= */
/* ADD: E.Farhi, Aug 6th, 2001: Monitor_nD section */
/* this routine is used to display component */
/* ========================================================================= */
void Monitor_nD_McDisplay(MonitornD_Defines_type *mc_mn_DEFS,
MonitornD_Variables_type *mc_mn_Vars)
{
double mc_mn_radius, mc_mn_h;
double mc_mn_xmin;
double mc_mn_xmax;
double mc_mn_ymin;
double mc_mn_ymax;
double mc_mn_zmin;
double mc_mn_zmax;
int mc_mn_i;
double mc_mn_hdiv_min=-180, mc_mn_hdiv_max=180, mc_mn_vdiv_min=-180, mc_mn_vdiv_max=180;
char mc_mn_restricted = 0;
mc_mn_radius = mc_mn_Vars->Sphere_Radius;
mc_mn_h = mc_mn_Vars->Cylinder_Height;
mc_mn_xmin = mc_mn_Vars->mxmin;
mc_mn_xmax = mc_mn_Vars->mxmax;
mc_mn_ymin = mc_mn_Vars->mymin;
mc_mn_ymax = mc_mn_Vars->mymax;
mc_mn_zmin = mc_mn_Vars->mzmin;
mc_mn_zmax = mc_mn_Vars->mzmax;
/* determine if there are angular limits set at start (no auto) in coord_types
* cylinder/banana: look for hdiv
* sphere: look for angle, radius (->atan2(val,mc_mn_radius)), hdiv, vdiv
* this activates a 'restricted' flag, to draw a region as blades on cylinder/sphere
*/
for (mc_mn_i= 0; mc_mn_i < mc_mn_Vars->Coord_Number; mc_mn_i++)
{
int mc_mn_Set_Vars_Coord_Type;
mc_mn_Set_Vars_Coord_Type = (mc_mn_Vars->Coord_Type[mc_mn_i] & 31);
if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_HDIV || mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_THETA)
{ mc_mn_hdiv_min = mc_mn_Vars->Coord_Min[mc_mn_i]; mc_mn_hdiv_max = mc_mn_Vars->Coord_Max[mc_mn_i]; mc_mn_restricted = 1; }
else if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_VDIV || mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_PHI)
{ mc_mn_vdiv_min = mc_mn_Vars->Coord_Min[mc_mn_i]; mc_mn_vdiv_max = mc_mn_Vars->Coord_Max[mc_mn_i];mc_mn_restricted = 1; }
else if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_ANGLE)
{ mc_mn_hdiv_min = mc_mn_vdiv_min = mc_mn_Vars->Coord_Min[mc_mn_i];
mc_mn_hdiv_max = mc_mn_vdiv_max = mc_mn_Vars->Coord_Max[mc_mn_i];
mc_mn_restricted = 1; }
else if (mc_mn_Set_Vars_Coord_Type == mc_mn_DEFS->COORD_RADIUS)
{ double angle;
angle = RAD2DEG*atan2(mc_mn_Vars->Coord_Max[mc_mn_i], mc_mn_radius);
mc_mn_hdiv_min = mc_mn_vdiv_min = angle;
mc_mn_hdiv_max = mc_mn_vdiv_max = angle;
mc_mn_restricted = 1; }
}
if (!mc_mn_restricted && (abs(mc_mn_Vars->Flag_Shape) == mc_mn_DEFS->SHAPE_SPHERE))
{
mcdis_magnify("");
mcdis_circle("xy",0,0,0,mc_mn_radius);
mcdis_circle("xz",0,0,0,mc_mn_radius);
mcdis_circle("yz",0,0,0,mc_mn_radius);
}
else if (mc_mn_restricted && ((abs(mc_mn_Vars->Flag_Shape) == mc_mn_DEFS->SHAPE_CYLIND) || (abs(mc_mn_Vars->Flag_Shape) == mc_mn_DEFS->SHAPE_BANANA) || (abs(mc_mn_Vars->Flag_Shape) == mc_mn_DEFS->SHAPE_SPHERE)))
{
int NH=24, NV=24;
int ih, iv;
double width, height;
int issphere;
issphere = (abs(mc_mn_Vars->Flag_Shape) == mc_mn_DEFS->SHAPE_SPHERE);
width = (mc_mn_hdiv_max-mc_mn_hdiv_min)/NH;
height= (mc_mn_vdiv_max-mc_mn_vdiv_min)/NV;
mcdis_magnify("xyz");
for(ih = 0; ih < NH; ih++)
for(iv = 0; iv < NV; iv++)
{
double theta0, phi0, theta1, phi1;
double x0,y0,z0,x1,y1,z1,x2,y2,z2,x3,y3,z3;
double ymin, ymax;
phi0 = (mc_mn_hdiv_min+ width*ih)*DEG2RAD; /* in xz plane */
phi1 = (mc_mn_hdiv_min+ width*(ih+1))*DEG2RAD;
if (issphere)
{
theta0= (90-mc_mn_vdiv_min+height*iv)*DEG2RAD;
theta1= (90-mc_mn_vdiv_min+height*(iv+1))*DEG2RAD;
} else
{
theta0= theta1 = PI/2;
ymin = mc_mn_ymin+(mc_mn_ymax-mc_mn_ymin)*(iv/NV);
ymax = mc_mn_ymin+(mc_mn_ymax-mc_mn_ymin)*((iv+1)/NV);
}
z0 = mc_mn_radius*sin(theta0)*cos(phi0);
x0 = mc_mn_radius*sin(theta0)*sin(phi0);
if (issphere) y0 = mc_mn_radius*cos(theta0); else y0 = ymin;
z1 = mc_mn_radius*sin(theta1)*cos(phi0);
x1 = mc_mn_radius*sin(theta1)*sin(phi0);
if (issphere) y1 = mc_mn_radius*cos(theta1); else y1 = ymax;
z2 = mc_mn_radius*sin(theta1)*cos(phi1);
x2 = mc_mn_radius*sin(theta1)*sin(phi1);
y2 = y1;
z3 = mc_mn_radius*sin(theta0)*cos(phi1);
x3 = mc_mn_radius*sin(theta0)*sin(phi1);
y3 = y0;
mcdis_multiline(5,
x0,y0,z0,
x1,y1,z1,
x2,y2,z2,
x3,y3,z3,
x0,y0,z0);
}
}
else
if (abs(mc_mn_Vars->Flag_Shape) == mc_mn_DEFS->SHAPE_DISK)
{
mcdis_magnify("");
mcdis_circle("xy",0,0,0,mc_mn_radius);
}
else
if (abs(mc_mn_Vars->Flag_Shape) == mc_mn_DEFS->SHAPE_SQUARE)
{
mcdis_magnify("xy");
mcdis_multiline(5, (double)mc_mn_xmin, (double)mc_mn_ymin, 0.0,
(double)mc_mn_xmax, (double)mc_mn_ymin, 0.0,
(double)mc_mn_xmax, (double)mc_mn_ymax, 0.0,
(double)mc_mn_xmin, (double)mc_mn_ymax, 0.0,
(double)mc_mn_xmin, (double)mc_mn_ymin, 0.0);
}
else
if (!mc_mn_restricted && ((abs(mc_mn_Vars->Flag_Shape) == mc_mn_DEFS->SHAPE_CYLIND) || (abs(mc_mn_Vars->Flag_Shape) == mc_mn_DEFS->SHAPE_BANANA)))
{
mcdis_magnify("xyz");
mcdis_circle("xz", 0, mc_mn_h/2.0, 0, mc_mn_radius);
mcdis_circle("xz", 0, -mc_mn_h/2.0, 0, mc_mn_radius);
mcdis_line(-mc_mn_radius, -mc_mn_h/2.0, 0, -mc_mn_radius, +mc_mn_h/2.0, 0);
mcdis_line(+mc_mn_radius, -mc_mn_h/2.0, 0, +mc_mn_radius, +mc_mn_h/2.0, 0);
mcdis_line(0, -mc_mn_h/2.0, -mc_mn_radius, 0, +mc_mn_h/2.0, -mc_mn_radius);
mcdis_line(0, -mc_mn_h/2.0, +mc_mn_radius, 0, +mc_mn_h/2.0, +mc_mn_radius);
}
else
if (abs(mc_mn_Vars->Flag_Shape) == mc_mn_DEFS->SHAPE_BOX)
{
mcdis_magnify("xyz");
mcdis_multiline(5, mc_mn_xmin, mc_mn_ymin, mc_mn_zmin,
mc_mn_xmax, mc_mn_ymin, mc_mn_zmin,
mc_mn_xmax, mc_mn_ymax, mc_mn_zmin,
mc_mn_xmin, mc_mn_ymax, mc_mn_zmin,
mc_mn_xmin, mc_mn_ymin, mc_mn_zmin);
mcdis_multiline(5, mc_mn_xmin, mc_mn_ymin, mc_mn_zmax,
mc_mn_xmax, mc_mn_ymin, mc_mn_zmax,
mc_mn_xmax, mc_mn_ymax, mc_mn_zmax,
mc_mn_xmin, mc_mn_ymax, mc_mn_zmax,
mc_mn_xmin, mc_mn_ymin, mc_mn_zmax);
mcdis_line(mc_mn_xmin, mc_mn_ymin, mc_mn_zmin, mc_mn_xmin, mc_mn_ymin, mc_mn_zmax);
mcdis_line(mc_mn_xmax, mc_mn_ymin, mc_mn_zmin, mc_mn_xmax, mc_mn_ymin, mc_mn_zmax);
mcdis_line(mc_mn_xmin, mc_mn_ymax, mc_mn_zmin, mc_mn_xmin, mc_mn_ymax, mc_mn_zmax);
mcdis_line(mc_mn_xmax, mc_mn_ymax, mc_mn_zmin, mc_mn_xmax, mc_mn_ymax, mc_mn_zmax);
}
} /* end Monitor_nD_McDisplay */
/* end of monitor_nd-lib.c */
syntax highlighted by Code2HTML, v. 0.9.1