int main (int argc, char **argv) { GOptionContext *ctx; GError *error = NULL; int ecode; g_setenv ("CLUTTER_DISABLE_XINPUT", "1", TRUE); bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); g_setenv ("GDK_SCALE", "1", TRUE); ctx = meta_get_option_context (); g_option_context_add_main_entries (ctx, gnome_cinnamon_options, GETTEXT_PACKAGE); if (!g_option_context_parse (ctx, &argc, &argv, &error)) { g_printerr ("%s: %s\n", argv[0], error->message); exit (1); } g_option_context_free (ctx); meta_plugin_manager_set_plugin_type (gnome_cinnamon_plugin_get_type ()); /* Prevent meta_init() from causing gtk to load gail and at-bridge */ g_setenv ("NO_GAIL", "1", TRUE); g_setenv ("NO_AT_BRIDGE", "1", TRUE); meta_init (); g_unsetenv ("NO_GAIL"); g_unsetenv ("NO_AT_BRIDGE"); g_unsetenv ("CLUTTER_DISABLE_XINPUT"); /* FIXME: Add gjs API to set this stuff and don't depend on the * environment. These propagate to child processes. */ g_setenv ("GJS_DEBUG_OUTPUT", "stderr", TRUE); g_setenv ("GJS_DEBUG_TOPICS", "JS ERROR;JS LOG", TRUE); g_setenv ("CINNAMON_VERSION", VERSION, TRUE); center_pointer_on_screen(); cinnamon_dbus_init (meta_get_replace_current_wm ()); cinnamon_a11y_init (); cinnamon_perf_log_init (); g_irepository_prepend_search_path (CINNAMON_PKGLIBDIR); #if HAVE_BLUETOOTH g_irepository_prepend_search_path (BLUETOOTH_DIR); #endif /* Disable debug spew from various libraries */ g_log_set_handler ("Gvc", G_LOG_LEVEL_DEBUG, muted_log_handler, NULL); g_log_set_handler ("AccountsService", G_LOG_LEVEL_DEBUG, muted_log_handler, NULL); g_log_set_handler ("Bluetooth", G_LOG_LEVEL_DEBUG | G_LOG_LEVEL_MESSAGE, muted_log_handler, NULL); /* Initialize the global object */ _cinnamon_global_init (NULL); queue_register_client (); g_unsetenv ("GDK_SCALE"); ecode = meta_run (); if (g_getenv ("CINNAMON_ENABLE_CLEANUP")) { g_printerr ("Doing final cleanup...\n"); g_object_unref (cinnamon_global_get ()); } return ecode; }
void on_integration_start() { char *errtext; EVENT_TRACE(fprintf(stderr, "%d: on_integration_start\n", this_node)); INTEG_TRACE(fprintf(stderr,"%d: on_integration_start: reinit_thermo = %d, resort_particles=%d\n", this_node,reinit_thermo,resort_particles)); /********************************************/ /* sanity checks */ /********************************************/ if ( time_step < 0.0 ) { errtext = runtime_error(128); ERROR_SPRINTF(errtext, "{010 time_step not set} "); } if ( skin < 0.0 ) { errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{011 skin not set} "); } if ( temperature < 0.0 ) { errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{012 thermostat not initialized} "); } #ifdef NPT if (integ_switch == INTEG_METHOD_NPT_ISO) { if (nptiso.piston <= 0.0) { char *errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{014 npt on, but piston mass not set} "); } #ifdef ELECTROSTATICS switch(coulomb.method) { case COULOMB_NONE: break; #ifdef P3M case COULOMB_P3M: break; #endif /*P3M*/ default: { char *errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{014 npt only works with P3M} "); } } #endif /*ELECTROSTATICS*/ #ifdef DIPOLES switch (coulomb.Dmethod) { case DIPOLAR_NONE: break; #ifdef DP3M case DIPOLAR_P3M: break; #endif default: { char *errtext = runtime_error(128); ERROR_SPRINTF(errtext,"NpT does not work with your dipolar method, please use P3M."); } } #endif /* ifdef DIPOLES */ } #endif /*NPT*/ if (!check_obs_calc_initialized()) return; #ifdef LB if(lattice_switch & LATTICE_LB) { if (lbpar.agrid <= 0.0) { errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{098 Lattice Boltzmann agrid not set} "); } if (lbpar.tau <= 0.0) { errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{099 Lattice Boltzmann time step not set} "); } if (lbpar.rho <= 0.0) { errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{100 Lattice Boltzmann fluid density not set} "); } if (lbpar.viscosity <= 0.0) { errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{101 Lattice Boltzmann fluid viscosity not set} "); } if (dd.use_vList && skin>=lbpar.agrid/2.0) { errtext = runtime_error(128); ERROR_SPRINTF(errtext, "{104 LB requires either no Verlet lists or that the skin of the verlet list to be less than half of lattice-Boltzmann grid spacing.} "); } } #endif #ifdef LB_GPU if(this_node == 0){ if(lattice_switch & LATTICE_LB_GPU) { if (lbpar_gpu.agrid < 0.0) { errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{098 Lattice Boltzmann agrid not set} "); } if (lbpar_gpu.tau < 0.0) { errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{099 Lattice Boltzmann time step not set} "); } if (lbpar_gpu.rho < 0.0) { errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{100 Lattice Boltzmann fluid density not set} "); } if (lbpar_gpu.viscosity < 0.0) { errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{101 Lattice Boltzmann fluid viscosity not set} "); } if (lb_reinit_particles_gpu) { lb_realloc_particles_gpu(); lb_reinit_particles_gpu = 0; } } } #endif #ifdef METADYNAMICS meta_init(); #endif #ifdef CATALYTIC_REACTIONS if(reaction.ct_rate != 0.0) { if( dd.use_vList == 0 || cell_structure.type != CELL_STRUCTURE_DOMDEC) { errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{105 The CATALYTIC_REACTIONS feature requires verlet lists and domain decomposition} "); check_runtime_errors(); } if(max_cut < reaction.range) { errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{106 Reaction range of %f exceeds maximum cutoff of %f} ", reaction.range, max_cut); } } #endif /********************************************/ /* end sanity checks */ /********************************************/ /* Prepare the thermostat */ if (reinit_thermo) { thermo_init(); reinit_thermo = 0; recalc_forces = 1; } /* Ensemble preparation: NVT or NPT */ integrate_ensemble_init(); /* Update particle and observable information for routines in statistics.c */ invalidate_obs(); freePartCfg(); on_observable_calc(); }
/*- * main -- * The main function, for obvious reasons. Initializes variables * and a few modules, then parses the arguments give it in the * environment and on the command line. Reads the system makefile * followed by either Makefile, makefile or the file given by the * -f argument. Sets the .MAKEFLAGS PMake variable based on all the * flags it has received by then uses either the Make or the Compat * module to create the initial list of targets. * * Results: * If -q was given, exits -1 if anything was out-of-date. Else it exits * 0. * * Side Effects: * The program exits when done. Targets are created. etc. etc. etc. */ int main(int argc, char **argv) { Lst targs; /* target nodes to create -- passed to Make_Init */ Boolean outOfDate = FALSE; /* FALSE if all targets up to date */ struct stat sb, sa; char *p1, *path; char mdpath[MAXPATHLEN]; #ifdef FORCE_MACHINE const char *machine = FORCE_MACHINE; #else const char *machine = getenv("MACHINE"); #endif const char *machine_arch = getenv("MACHINE_ARCH"); char *syspath = getenv("MAKESYSPATH"); Lst sysMkPath; /* Path of sys.mk */ char *cp = NULL, *start; /* avoid faults on read-only strings */ static char defsyspath[] = _PATH_DEFSYSPATH; char found_path[MAXPATHLEN + 1]; /* for searching for sys.mk */ struct timeval rightnow; /* to initialize random seed */ struct utsname utsname; /* default to writing debug to stderr */ debug_file = stderr; #ifdef SIGINFO (void)bmake_signal(SIGINFO, siginfo); #endif /* * Set the seed to produce a different random sequence * on each program execution. */ gettimeofday(&rightnow, NULL); srandom(rightnow.tv_sec + rightnow.tv_usec); if ((progname = strrchr(argv[0], '/')) != NULL) progname++; else progname = argv[0]; #if defined(MAKE_NATIVE) || (defined(HAVE_SETRLIMIT) && defined(RLIMIT_NOFILE)) /* * get rid of resource limit on file descriptors */ { struct rlimit rl; if (getrlimit(RLIMIT_NOFILE, &rl) != -1 && rl.rlim_cur != rl.rlim_max) { rl.rlim_cur = rl.rlim_max; (void)setrlimit(RLIMIT_NOFILE, &rl); } } #endif if (uname(&utsname) == -1) { (void)fprintf(stderr, "%s: uname failed (%s).\n", progname, strerror(errno)); exit(2); } /* * Get the name of this type of MACHINE from utsname * so we can share an executable for similar machines. * (i.e. m68k: amiga hp300, mac68k, sun3, ...) * * Note that both MACHINE and MACHINE_ARCH are decided at * run-time. */ if (!machine) { #ifdef MAKE_NATIVE machine = utsname.machine; #else #ifdef MAKE_MACHINE machine = MAKE_MACHINE; #else machine = "unknown"; #endif #endif } if (!machine_arch) { #if defined(MAKE_NATIVE) && defined(HAVE_SYSCTL) && defined(CTL_HW) && defined(HW_MACHINE_ARCH) static char machine_arch_buf[sizeof(utsname.machine)]; int mib[2] = { CTL_HW, HW_MACHINE_ARCH }; size_t len = sizeof(machine_arch_buf); if (sysctl(mib, __arraycount(mib), machine_arch_buf, &len, NULL, 0) < 0) { (void)fprintf(stderr, "%s: sysctl failed (%s).\n", progname, strerror(errno)); exit(2); } machine_arch = machine_arch_buf; #else #ifndef MACHINE_ARCH #ifdef MAKE_MACHINE_ARCH machine_arch = MAKE_MACHINE_ARCH; #else machine_arch = "unknown"; #endif #else machine_arch = MACHINE_ARCH; #endif #endif } myPid = getpid(); /* remember this for vFork() */ /* * Just in case MAKEOBJDIR wants us to do something tricky. */ Var_Init(); /* Initialize the lists of variables for * parsing arguments */ Var_Set(".MAKE.OS", utsname.sysname, VAR_GLOBAL, 0); Var_Set("MACHINE", machine, VAR_GLOBAL, 0); Var_Set("MACHINE_ARCH", machine_arch, VAR_GLOBAL, 0); #ifdef MAKE_VERSION Var_Set("MAKE_VERSION", MAKE_VERSION, VAR_GLOBAL, 0); #endif Var_Set(".newline", "\n", VAR_GLOBAL, 0); /* handy for :@ loops */ /* * This is the traditional preference for makefiles. */ #ifndef MAKEFILE_PREFERENCE_LIST # define MAKEFILE_PREFERENCE_LIST "makefile Makefile" #endif Var_Set(MAKEFILE_PREFERENCE, MAKEFILE_PREFERENCE_LIST, VAR_GLOBAL, 0); Var_Set(MAKE_DEPENDFILE, ".depend", VAR_GLOBAL, 0); create = Lst_Init(FALSE); makefiles = Lst_Init(FALSE); printVars = FALSE; debugVflag = FALSE; variables = Lst_Init(FALSE); beSilent = FALSE; /* Print commands as executed */ ignoreErrors = FALSE; /* Pay attention to non-zero returns */ noExecute = FALSE; /* Execute all commands */ noRecursiveExecute = FALSE; /* Execute all .MAKE targets */ keepgoing = FALSE; /* Stop on error */ allPrecious = FALSE; /* Remove targets when interrupted */ queryFlag = FALSE; /* This is not just a check-run */ noBuiltins = FALSE; /* Read the built-in rules */ touchFlag = FALSE; /* Actually update targets */ debug = 0; /* No debug verbosity, please. */ jobsRunning = FALSE; maxJobs = DEFMAXLOCAL; /* Set default local max concurrency */ maxJobTokens = maxJobs; compatMake = FALSE; /* No compat mode */ ignorePWD = FALSE; /* * Initialize the parsing, directory and variable modules to prepare * for the reading of inclusion paths and variable settings on the * command line */ /* * Initialize various variables. * MAKE also gets this name, for compatibility * .MAKEFLAGS gets set to the empty string just in case. * MFLAGS also gets initialized empty, for compatibility. */ Parse_Init(); if (argv[0][0] == '/' || strchr(argv[0], '/') == NULL) { /* * Leave alone if it is an absolute path, or if it does * not contain a '/' in which case we need to find it in * the path, like execvp(3) and the shells do. */ p1 = argv[0]; } else { /* * A relative path, canonicalize it. */ p1 = cached_realpath(argv[0], mdpath); if (!p1 || *p1 != '/' || stat(p1, &sb) < 0) { p1 = argv[0]; /* realpath failed */ } } Var_Set("MAKE", p1, VAR_GLOBAL, 0); Var_Set(".MAKE", p1, VAR_GLOBAL, 0); Var_Set(MAKEFLAGS, "", VAR_GLOBAL, 0); Var_Set(MAKEOVERRIDES, "", VAR_GLOBAL, 0); Var_Set("MFLAGS", "", VAR_GLOBAL, 0); Var_Set(".ALLTARGETS", "", VAR_GLOBAL, 0); /* some makefiles need to know this */ Var_Set(MAKE_LEVEL ".ENV", MAKE_LEVEL_ENV, VAR_CMD, 0); /* * Set some other useful macros */ { char tmp[64], *ep; makelevel = ((ep = getenv(MAKE_LEVEL_ENV)) && *ep) ? atoi(ep) : 0; if (makelevel < 0) makelevel = 0; snprintf(tmp, sizeof(tmp), "%d", makelevel); Var_Set(MAKE_LEVEL, tmp, VAR_GLOBAL, 0); snprintf(tmp, sizeof(tmp), "%u", myPid); Var_Set(".MAKE.PID", tmp, VAR_GLOBAL, 0); snprintf(tmp, sizeof(tmp), "%u", getppid()); Var_Set(".MAKE.PPID", tmp, VAR_GLOBAL, 0); } if (makelevel > 0) { char pn[1024]; snprintf(pn, sizeof(pn), "%s[%d]", progname, makelevel); progname = bmake_strdup(pn); } #ifdef USE_META meta_init(); #endif /* * First snag any flags out of the MAKE environment variable. * (Note this is *not* MAKEFLAGS since /bin/make uses that and it's * in a different format). */ #ifdef POSIX p1 = explode(getenv("MAKEFLAGS")); Main_ParseArgLine(p1); free(p1); #else Main_ParseArgLine(getenv("MAKE")); #endif /* * Find where we are (now). * We take care of PWD for the automounter below... */ if (getcwd(curdir, MAXPATHLEN) == NULL) { (void)fprintf(stderr, "%s: getcwd: %s.\n", progname, strerror(errno)); exit(2); } MainParseArgs(argc, argv); if (enterFlag) printf("%s: Entering directory `%s'\n", progname, curdir); /* * Verify that cwd is sane. */ if (stat(curdir, &sa) == -1) { (void)fprintf(stderr, "%s: %s: %s.\n", progname, curdir, strerror(errno)); exit(2); } /* * All this code is so that we know where we are when we start up * on a different machine with pmake. * Overriding getcwd() with $PWD totally breaks MAKEOBJDIRPREFIX * since the value of curdir can vary depending on how we got * here. Ie sitting at a shell prompt (shell that provides $PWD) * or via subdir.mk in which case its likely a shell which does * not provide it. * So, to stop it breaking this case only, we ignore PWD if * MAKEOBJDIRPREFIX is set or MAKEOBJDIR contains a transform. */ #ifndef NO_PWD_OVERRIDE if (!ignorePWD) { char *pwd, *ptmp1 = NULL, *ptmp2 = NULL; if ((pwd = getenv("PWD")) != NULL && Var_Value("MAKEOBJDIRPREFIX", VAR_CMD, &ptmp1) == NULL) { const char *makeobjdir = Var_Value("MAKEOBJDIR", VAR_CMD, &ptmp2); if (makeobjdir == NULL || !strchr(makeobjdir, '$')) { if (stat(pwd, &sb) == 0 && sa.st_ino == sb.st_ino && sa.st_dev == sb.st_dev) (void)strncpy(curdir, pwd, MAXPATHLEN); } } free(ptmp1); free(ptmp2); } #endif Var_Set(".CURDIR", curdir, VAR_GLOBAL, 0); /* * Find the .OBJDIR. If MAKEOBJDIRPREFIX, or failing that, * MAKEOBJDIR is set in the environment, try only that value * and fall back to .CURDIR if it does not exist. * * Otherwise, try _PATH_OBJDIR.MACHINE, _PATH_OBJDIR, and * finally _PATH_OBJDIRPREFIX`pwd`, in that order. If none * of these paths exist, just use .CURDIR. */ Dir_Init(curdir); (void)Main_SetObjdir(curdir); if ((path = Var_Value("MAKEOBJDIRPREFIX", VAR_CMD, &p1)) != NULL) { (void)snprintf(mdpath, MAXPATHLEN, "%s%s", path, curdir); (void)Main_SetObjdir(mdpath); free(p1); } else if ((path = Var_Value("MAKEOBJDIR", VAR_CMD, &p1)) != NULL) { (void)Main_SetObjdir(path); free(p1); } else { (void)snprintf(mdpath, MAXPATHLEN, "%s.%s", _PATH_OBJDIR, machine); if (!Main_SetObjdir(mdpath) && !Main_SetObjdir(_PATH_OBJDIR)) { (void)snprintf(mdpath, MAXPATHLEN, "%s%s", _PATH_OBJDIRPREFIX, curdir); (void)Main_SetObjdir(mdpath); } } /* * Initialize archive, target and suffix modules in preparation for * parsing the makefile(s) */ Arch_Init(); Targ_Init(); Suff_Init(); Trace_Init(tracefile); DEFAULT = NULL; (void)time(&now); Trace_Log(MAKESTART, NULL); /* * Set up the .TARGETS variable to contain the list of targets to be * created. If none specified, make the variable empty -- the parser * will fill the thing in with the default or .MAIN target. */ if (!Lst_IsEmpty(create)) { LstNode ln; for (ln = Lst_First(create); ln != NULL; ln = Lst_Succ(ln)) { char *name = (char *)Lst_Datum(ln); Var_Append(".TARGETS", name, VAR_GLOBAL); } } else Var_Set(".TARGETS", "", VAR_GLOBAL, 0); /* * If no user-supplied system path was given (through the -m option) * add the directories from the DEFSYSPATH (more than one may be given * as dir1:...:dirn) to the system include path. */ if (syspath == NULL || *syspath == '\0') syspath = defsyspath; else syspath = bmake_strdup(syspath); for (start = syspath; *start != '\0'; start = cp) { for (cp = start; *cp != '\0' && *cp != ':'; cp++) continue; if (*cp == ':') { *cp++ = '\0'; } /* look for magic parent directory search string */ if (strncmp(".../", start, 4) != 0) { (void)Dir_AddDir(defIncPath, start); } else { if (Dir_FindHereOrAbove(curdir, start+4, found_path, sizeof(found_path))) { (void)Dir_AddDir(defIncPath, found_path); } } } if (syspath != defsyspath) free(syspath); /* * Read in the built-in rules first, followed by the specified * makefile, if it was (makefile != NULL), or the default * makefile and Makefile, in that order, if it wasn't. */ if (!noBuiltins) { LstNode ln; sysMkPath = Lst_Init(FALSE); Dir_Expand(_PATH_DEFSYSMK, Lst_IsEmpty(sysIncPath) ? defIncPath : sysIncPath, sysMkPath); if (Lst_IsEmpty(sysMkPath)) Fatal("%s: no system rules (%s).", progname, _PATH_DEFSYSMK); ln = Lst_Find(sysMkPath, NULL, ReadMakefile); if (ln == NULL) Fatal("%s: cannot open %s.", progname, (char *)Lst_Datum(ln)); } if (!Lst_IsEmpty(makefiles)) { LstNode ln; ln = Lst_Find(makefiles, NULL, ReadAllMakefiles); if (ln != NULL) Fatal("%s: cannot open %s.", progname, (char *)Lst_Datum(ln)); } else { p1 = Var_Subst(NULL, "${" MAKEFILE_PREFERENCE "}", VAR_CMD, VARF_WANTRES); if (p1) { (void)str2Lst_Append(makefiles, p1, NULL); (void)Lst_Find(makefiles, NULL, ReadMakefile); free(p1); } } /* In particular suppress .depend for '-r -V .OBJDIR -f /dev/null' */ if (!noBuiltins || !printVars) { makeDependfile = Var_Subst(NULL, "${.MAKE.DEPENDFILE:T}", VAR_CMD, VARF_WANTRES); doing_depend = TRUE; (void)ReadMakefile(makeDependfile, NULL); doing_depend = FALSE; } if (enterFlagObj) printf("%s: Entering directory `%s'\n", progname, objdir); MakeMode(NULL); Var_Append("MFLAGS", Var_Value(MAKEFLAGS, VAR_GLOBAL, &p1), VAR_GLOBAL); free(p1); if (!forceJobs && !compatMake && Var_Exists(".MAKE.JOBS", VAR_GLOBAL)) { char *value; int n; value = Var_Subst(NULL, "${.MAKE.JOBS}", VAR_GLOBAL, VARF_WANTRES); n = strtol(value, NULL, 0); if (n < 1) { (void)fprintf(stderr, "%s: illegal value for .MAKE.JOBS -- must be positive integer!\n", progname); exit(1); } if (n != maxJobs) { Var_Append(MAKEFLAGS, "-j", VAR_GLOBAL); Var_Append(MAKEFLAGS, value, VAR_GLOBAL); } maxJobs = n; maxJobTokens = maxJobs; forceJobs = TRUE; free(value); } /* * Be compatible if user did not specify -j and did not explicitly * turned compatibility on */ if (!compatMake && !forceJobs) { compatMake = TRUE; } if (!compatMake) Job_ServerStart(maxJobTokens, jp_0, jp_1); if (DEBUG(JOB)) fprintf(debug_file, "job_pipe %d %d, maxjobs %d, tokens %d, compat %d\n", jp_0, jp_1, maxJobs, maxJobTokens, compatMake); Main_ExportMAKEFLAGS(TRUE); /* initial export */ /* * For compatibility, look at the directories in the VPATH variable * and add them to the search path, if the variable is defined. The * variable's value is in the same format as the PATH envariable, i.e. * <directory>:<directory>:<directory>... */ if (Var_Exists("VPATH", VAR_CMD)) { char *vpath, savec; /* * GCC stores string constants in read-only memory, but * Var_Subst will want to write this thing, so store it * in an array */ static char VPATH[] = "${VPATH}"; vpath = Var_Subst(NULL, VPATH, VAR_CMD, VARF_WANTRES); path = vpath; do { /* skip to end of directory */ for (cp = path; *cp != ':' && *cp != '\0'; cp++) continue; /* Save terminator character so know when to stop */ savec = *cp; *cp = '\0'; /* Add directory to search path */ (void)Dir_AddDir(dirSearchPath, path); *cp = savec; path = cp + 1; } while (savec == ':'); free(vpath); } /* * Now that all search paths have been read for suffixes et al, it's * time to add the default search path to their lists... */ Suff_DoPaths(); /* * Propagate attributes through :: dependency lists. */ Targ_Propagate(); /* print the initial graph, if the user requested it */ if (DEBUG(GRAPH1)) Targ_PrintGraph(1); /* print the values of any variables requested by the user */ if (printVars) { LstNode ln; Boolean expandVars; if (debugVflag) expandVars = FALSE; else expandVars = getBoolean(".MAKE.EXPAND_VARIABLES", FALSE); for (ln = Lst_First(variables); ln != NULL; ln = Lst_Succ(ln)) { char *var = (char *)Lst_Datum(ln); char *value; if (strchr(var, '$')) { value = p1 = Var_Subst(NULL, var, VAR_GLOBAL, VARF_WANTRES); } else if (expandVars) { char tmp[128]; if (snprintf(tmp, sizeof(tmp), "${%s}", var) >= (int)(sizeof(tmp))) Fatal("%s: variable name too big: %s", progname, var); value = p1 = Var_Subst(NULL, tmp, VAR_GLOBAL, VARF_WANTRES); } else { value = Var_Value(var, VAR_GLOBAL, &p1); } printf("%s\n", value ? value : ""); free(p1); } } else { /* * Have now read the entire graph and need to make a list of * targets to create. If none was given on the command line, * we consult the parsing module to find the main target(s) * to create. */ if (Lst_IsEmpty(create)) targs = Parse_MainName(); else targs = Targ_FindList(create, TARG_CREATE); if (!compatMake) { /* * Initialize job module before traversing the graph * now that any .BEGIN and .END targets have been read. * This is done only if the -q flag wasn't given * (to prevent the .BEGIN from being executed should * it exist). */ if (!queryFlag) { Job_Init(); jobsRunning = TRUE; } /* Traverse the graph, checking on all the targets */ outOfDate = Make_Run(targs); } else { /* * Compat_Init will take care of creating all the * targets as well as initializing the module. */ Compat_Run(targs); } } #ifdef CLEANUP Lst_Destroy(targs, NULL); Lst_Destroy(variables, NULL); Lst_Destroy(makefiles, NULL); Lst_Destroy(create, (FreeProc *)free); #endif /* print the graph now it's been processed if the user requested it */ if (DEBUG(GRAPH2)) Targ_PrintGraph(2); Trace_Log(MAKEEND, 0); if (enterFlagObj) printf("%s: Leaving directory `%s'\n", progname, objdir); if (enterFlag) printf("%s: Leaving directory `%s'\n", progname, curdir); #ifdef USE_META meta_finish(); #endif Suff_End(); Targ_End(); Arch_End(); Var_End(); Parse_End(); Dir_End(); Job_End(); Trace_End(); return outOfDate ? 1 : 0; }
int main (int argc, char **argv) { GOptionContext *ctx; GError *error = NULL; int ecode; TpDebugSender *sender; bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); session_mode = (char *) g_getenv ("GNOME_SHELL_SESSION_MODE"); ctx = meta_get_option_context (); g_option_context_add_main_entries (ctx, gnome_shell_options, GETTEXT_PACKAGE); g_option_context_add_group (ctx, g_irepository_get_option_group ()); if (!g_option_context_parse (ctx, &argc, &argv, &error)) { g_printerr ("%s: %s\n", argv[0], error->message); exit (1); } g_option_context_free (ctx); meta_plugin_manager_set_plugin_type (gnome_shell_plugin_get_type ()); meta_set_wm_name (WM_NAME); meta_set_gnome_wm_keybindings (GNOME_WM_KEYBINDINGS); meta_init (); /* FIXME: Add gjs API to set this stuff and don't depend on the * environment. These propagate to child processes. */ g_setenv ("GJS_DEBUG_OUTPUT", "stderr", TRUE); g_setenv ("GJS_DEBUG_TOPICS", "JS ERROR;JS LOG", TRUE); shell_init_debug (g_getenv ("SHELL_DEBUG")); shell_dbus_init (meta_get_replace_current_wm ()); shell_a11y_init (); shell_perf_log_init (); shell_introspection_init (); shell_fonts_init (); /* Turn on telepathy-glib debugging but filter it out in * default_log_handler. This handler also exposes all the logs over D-Bus * using TpDebugSender. */ tp_debug_set_flags ("all"); sender = tp_debug_sender_dup (); g_log_set_default_handler (default_log_handler, sender); /* Initialize the global object */ if (session_mode == NULL) session_mode = is_gdm_mode ? "gdm" : "user"; _shell_global_init ("session-mode", session_mode, NULL); shell_prefs_init (); ecode = meta_run (); if (g_getenv ("GNOME_SHELL_ENABLE_CLEANUP")) { g_printerr ("Doing final cleanup...\n"); g_object_unref (shell_global_get ()); } g_object_unref (sender); return ecode; }
int main (int argc, char **argv) { GOptionContext *ctx; GError *error = NULL; CinnamonSessionType session_type; int ecode; TpDebugSender *sender; g_type_init (); bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); ctx = meta_get_option_context (); g_option_context_add_main_entries (ctx, gnome_cinnamon_options, GETTEXT_PACKAGE); if (!g_option_context_parse (ctx, &argc, &argv, &error)) { g_printerr ("%s: %s\n", argv[0], error->message); exit (1); } g_option_context_free (ctx); meta_plugin_type_register (gnome_cinnamon_plugin_get_type ()); /* Prevent meta_init() from causing gtk to load gail and at-bridge */ g_setenv ("NO_GAIL", "1", TRUE); g_setenv ("NO_AT_BRIDGE", "1", TRUE); meta_init (); g_unsetenv ("NO_GAIL"); g_unsetenv ("NO_AT_BRIDGE"); /* FIXME: Add gjs API to set this stuff and don't depend on the * environment. These propagate to child processes. */ g_setenv ("GJS_DEBUG_OUTPUT", "stderr", TRUE); g_setenv ("GJS_DEBUG_TOPICS", "JS ERROR;JS LOG", TRUE); cinnamon_dbus_init (meta_get_replace_current_wm ()); cinnamon_a11y_init (); cinnamon_perf_log_init (); cinnamon_prefs_init (); g_irepository_prepend_search_path (CINNAMON_PKGLIBDIR); #if HAVE_BLUETOOTH g_irepository_prepend_search_path (BLUETOOTH_DIR); #endif /* Disable debug spew from various libraries */ g_log_set_handler ("Gvc", G_LOG_LEVEL_DEBUG, muted_log_handler, NULL); g_log_set_handler ("AccountsService", G_LOG_LEVEL_DEBUG, muted_log_handler, NULL); g_log_set_handler ("Bluetooth", G_LOG_LEVEL_DEBUG | G_LOG_LEVEL_MESSAGE, muted_log_handler, NULL); g_log_set_handler ("tp-glib/proxy", G_LOG_LEVEL_DEBUG, muted_log_handler, NULL); /* Turn on telepathy-glib debugging but filter it out in * default_log_handler. This handler also exposes all the logs over D-Bus * using TpDebugSender. */ tp_debug_set_flags ("all"); sender = tp_debug_sender_dup (); g_log_set_default_handler (default_log_handler, sender); /* Initialize the global object */ if (is_gdm_mode) session_type = CINNAMON_SESSION_GDM; else session_type = CINNAMON_SESSION_USER; _cinnamon_global_init ("session-type", session_type, NULL); ecode = meta_run (); if (g_getenv ("CINNAMON_ENABLE_CLEANUP")) { g_printerr ("Doing final cleanup...\n"); g_object_unref (cinnamon_global_get ()); } g_object_unref (sender); return ecode; }
void on_integration_start() { EVENT_TRACE(fprintf(stderr, "%d: on_integration_start\n", this_node)); INTEG_TRACE(fprintf(stderr,"%d: on_integration_start: reinit_thermo = %d, resort_particles=%d\n", this_node,reinit_thermo,resort_particles)); /********************************************/ /* sanity checks */ /********************************************/ integrator_sanity_checks(); #ifdef NPT integrator_npt_sanity_checks(); #endif interactions_sanity_checks(); #ifdef CATALYTIC_REACTIONS reactions_sanity_checks(); #endif #ifdef LB if(lattice_switch & LATTICE_LB) { lb_sanity_checks(); } #endif #ifdef LB_GPU if(lattice_switch & LATTICE_LB_GPU) { lb_GPU_sanity_checks(); } #endif /********************************************/ /* end sanity checks */ /********************************************/ #ifdef LB_GPU if(this_node == 0){ if (lb_reinit_particles_gpu) { lb_realloc_particles_gpu(); lb_reinit_particles_gpu = 0; } } #endif #ifdef CUDA if (reinit_particle_comm_gpu){ gpu_change_number_of_part_to_comm(); reinit_particle_comm_gpu = 0; } MPI_Bcast(gpu_get_global_particle_vars_pointer_host(), sizeof(CUDA_global_part_vars), MPI_BYTE, 0, comm_cart); #endif #ifdef METADYNAMICS meta_init(); #endif /* Prepare the thermostat */ if (reinit_thermo) { thermo_init(); reinit_thermo = 0; recalc_forces = 1; } /* Ensemble preparation: NVT or NPT */ integrate_ensemble_init(); /* Update particle and observable information for routines in statistics.cpp */ invalidate_obs(); freePartCfg(); on_observable_calc(); }
int tclcommand_metadynamics_parse_load_stat(Tcl_Interp *interp, int argc, char **argv){ /* Parse free energy profile and biased force that were provided from an * earlier simulation. Allows one to restart from a loaded state, and can * even be used to allow multiple walkers communicating their data through TCL. */ if(meta_switch == META_OFF) { Tcl_AppendResult(interp, "Metadynamics hasn't been initialized yet", (char *)NULL); return (TCL_ERROR); } argc -= 1; argv += 1; // There should be if (argc != 3) { Tcl_AppendResult(interp, "Incorrect number of arguments: 'metadynamics load_stat <profile_list> <force_list>'", (char *)NULL); return (TCL_ERROR); } // load free energy profile int i, tmp_argc, parse_error = 0, empty_line=0; char **tmp_argv; DoubleList profile, force; init_doublelist(&profile); Tcl_ResetResult(interp); Tcl_SplitList(interp, argv[1], &tmp_argc, (const char ***)&tmp_argv); realloc_doublelist(&profile, profile.n = tmp_argc); //printf("profile.n %d, meta_xi_num_bins %d\n",profile.n,meta_xi_num_bins); /* Now check that the number of items parsed is equal to the number of bins */ /* If there's one extra line, assume it's an empty line */ if (profile.n == meta_xi_num_bins+1) empty_line = 1; else if (profile.n != meta_xi_num_bins) { Tcl_AppendResult(interp, "Size of profile list loaded is different than expected from number of bins", (char *)NULL); return (TCL_ERROR); } /* call meta_init() in case it has been loaded yet */ meta_init(); for(i = 0 ; i < tmp_argc-empty_line; i++) { int tmp_argc2; char **tmp_argv2; Tcl_SplitList(interp, tmp_argv[i], &tmp_argc2, (const char ***)&tmp_argv2); if (tmp_argc2 != 1) { Tcl_AppendResult(interp, "data set has to be a list of doubles", (char *) NULL); parse_error = 1; break; } if (Tcl_GetDouble(interp, tmp_argv2[0], &(profile.e[i])) == TCL_ERROR) { parse_error = 1; break; } /* Load data into meta_acc_fprofile */ meta_acc_fprofile[i] = profile.e[i]; Tcl_Free((char *)tmp_argv2); } Tcl_Free((char *)tmp_argv); if (parse_error) return TCL_ERROR; // load force argc -= 1; argv += 1; init_doublelist(&force); Tcl_ResetResult(interp); Tcl_SplitList(interp, argv[1], &tmp_argc, (const char ***)&tmp_argv); realloc_doublelist(&force, force.n = tmp_argc); /* Now check that the number of items parsed is equal to the number of bins */ if (profile.n == meta_xi_num_bins+1) empty_line = 1; else if (profile.n != meta_xi_num_bins) { Tcl_AppendResult(interp, "Size of force list loaded is different than expected from number of bins", (char *)NULL); return (TCL_ERROR); } for(i = 0 ; i < tmp_argc-empty_line; i++) { int tmp_argc2; char **tmp_argv2; Tcl_SplitList(interp, tmp_argv[i], &tmp_argc2, (const char ***)&tmp_argv2); if (tmp_argc2 != 1) { Tcl_AppendResult(interp, "data set has to be a list of doubles", (char *) NULL); parse_error = 1; break; } if (Tcl_GetDouble(interp, tmp_argv2[0], &(force.e[i])) == TCL_ERROR) { parse_error = 1; break; } /* Load data into meta_acc_fprofile */ meta_acc_force[i] = -1.*force.e[i]; Tcl_Free((char *)tmp_argv2); } Tcl_Free((char *)tmp_argv); if (parse_error) return TCL_ERROR; return (TCL_OK); }
void on_integration_start() { char *errtext; int i; EVENT_TRACE(fprintf(stderr, "%d: on_integration_start\n", this_node)); INTEG_TRACE(fprintf(stderr,"%d: on_integration_start: reinit_thermo = %d, resort_particles=%d\n", this_node,reinit_thermo,resort_particles)); /********************************************/ /* sanity checks */ /********************************************/ if ( time_step < 0.0 ) { errtext = runtime_error(128); ERROR_SPRINTF(errtext, "{010 time_step not set} "); } if ( skin < 0.0 ) { errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{011 skin not set} "); } if ( temperature < 0.0 ) { errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{012 thermostat not initialized} "); } for (i = 0; i < 3; i++) if (local_box_l[i] < max_range) { errtext = runtime_error(128 + TCL_INTEGER_SPACE); ERROR_SPRINTF(errtext,"{013 box_l in direction %d is still too small} ", i); } #ifdef NPT if (integ_switch == INTEG_METHOD_NPT_ISO) { if (nptiso.piston <= 0.0) { char *errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{014 npt on, but piston mass not set} "); } if(cell_structure.type!=CELL_STRUCTURE_DOMDEC) { char *errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{014 npt requires domain decomposition cellsystem} "); } #ifdef ELECTROSTATICS switch(coulomb.method) { case COULOMB_NONE: break; #ifdef ELP3M case COULOMB_P3M: break; #endif /*ELP3M*/ case COULOMB_EWALD: break; default: { char *errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{014 npt only works with Ewald sum or P3M} "); } } #endif /*ELECTROSTATICS*/ } #endif /*NPT*/ if (!check_obs_calc_initialized()) return; #ifdef LB if(lattice_switch & LATTICE_LB) { if (lbpar.agrid <= 0.0) { errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{098 Lattice Boltzmann agrid not set} "); } if (lbpar.tau <= 0.0) { errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{099 Lattice Boltzmann time step not set} "); } if (lbpar.rho <= 0.0) { errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{100 Lattice Boltzmann fluid density not set} "); } if (lbpar.viscosity <= 0.0) { errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{101 Lattice Boltzmann fluid viscosity not set} "); } } #endif #ifdef LB_GPU if(this_node == 0){ if(lattice_switch & LATTICE_LB_GPU) { if (lbpar_gpu.agrid < 0.0) { errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{098 Lattice Boltzmann agrid not set} "); } if (lbpar_gpu.tau < 0.0) { errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{099 Lattice Boltzmann time step not set} "); } if (lbpar_gpu.rho < 0.0) { errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{100 Lattice Boltzmann fluid density not set} "); } if (lbpar_gpu.viscosity < 0.0) { errtext = runtime_error(128); ERROR_SPRINTF(errtext,"{101 Lattice Boltzmann fluid viscosity not set} "); } if (lb_reinit_particles_gpu) { lb_realloc_particles_gpu(); lb_reinit_particles_gpu = 0; } } } #endif #ifdef METADYNAMICS meta_init(); #endif /********************************************/ /* end sanity checks */ /********************************************/ /* Prepare the thermostat */ if (reinit_thermo) { thermo_init(); reinit_thermo = 0; recalc_forces = 1; } /* Ensemble preparation: NVT or NPT */ integrate_ensemble_init(); /* Update particle and observable information for routines in statistics.c */ invalidate_obs(); freePartCfg(); on_observable_calc(); }
int main (int argc, char **argv) { GOptionContext *ctx; GError *error = NULL; /* First parse the arguments that are passed to us */ ctx = g_option_context_new (NULL); g_option_context_add_main_entries (ctx, options, NULL); if (!g_option_context_parse (ctx, &argc, &argv, &error)) { g_printerr ("%s", error->message); return 1; } g_option_context_free (ctx); GPtrArray *tests = g_ptr_array_new (); if (all_tests) { GFile *test_dir = g_file_new_for_path (MUTTER_PKGDATADIR "/tests"); if (!find_metatests_in_directory (test_dir, tests, &error)) { g_printerr ("Error enumerating tests: %s\n", error->message); return 1; } } else { int i; char *curdir = g_get_current_dir (); for (i = 1; i < argc; i++) { if (g_path_is_absolute (argv[i])) g_ptr_array_add (tests, g_strdup (argv[i])); else g_ptr_array_add (tests, g_build_filename (curdir, argv[i], NULL)); } g_free (curdir); } /* Then initalize mutter with a different set of arguments */ char *fake_args[] = { NULL, (char *)"--wayland" }; fake_args[0] = argv[0]; char **fake_argv = fake_args; int fake_argc = 2; char *basename = g_path_get_basename (argv[0]); char *dirname = g_path_get_dirname (argv[0]); if (g_str_has_prefix (basename, "lt-")) test_client_path = g_build_filename (dirname, "../mutter-test-client", NULL); else test_client_path = g_build_filename (dirname, "mutter-test-client", NULL); g_free (basename); g_free (dirname); ctx = meta_get_option_context (); if (!g_option_context_parse (ctx, &fake_argc, &fake_argv, &error)) { g_printerr ("mutter: %s\n", error->message); exit (1); } g_option_context_free (ctx); meta_plugin_manager_load ("default"); meta_init (); meta_register_with_session (); RunTestsInfo info; info.tests = (char **)tests->pdata; info.n_tests = tests->len; g_idle_add (run_tests, &info); return meta_run (); }
int main(int argc, char *argv[]) { char szImg[255], szImage[255], buffer[1000], crID[10], szCrList[255], szOut[255]; int ii, kk, size, bigSize=oversampling_factor*srcSize; int mainlobe_azimuth_min, mainlobe_azimuth_max, mainlobe_range_min; int mainlobe_range_max, sidelobe_azimuth_min, sidelobe_azimuth_max; int sidelobe_range_min, sidelobe_range_max, peak_line, peak_sample; float azimuth_processing_bandwidth, chirp_rate, pulse_duration, sampling_rate; float prf, srcPeakX, srcPeakY, bigPeakX, bigPeakY, clutter_power, peak_power, scr; float azimuth_resolution, range_resolution, azimuth_pslr, range_pslr; float azimuth_window_size, range_window_size; float azimuth_profile[bigSize], range_profile[bigSize]; static complexFloat *s, *t; double lat, lon, elev, posX, posY, look_angle; FILE *fpIn, *fpOut, *fp, *fpText; meta_parameters *meta, *meta_debug; float *original_amplitude, *amplitude, *phase; fcpx *src_fft, *trg_fft; int debug=FALSE; char *text=NULL; int overwrite=FALSE; if (argc==1) usage(); if (strcmp(argv[1],"-help")==0) help_page(); /* exits program */ if (strcmp(argv[1],"-overwrite")==0) overwrite=TRUE; int required_args = 4; if (overwrite) ++required_args; if(argc != required_args) usage();/*This exits with a failure*/ /* Fetch required arguments */ strcpy(szImg, argv[argc - 3]); strcpy(szCrList,argv[argc - 2]); strcpy(szOut,argv[argc - 1]); /* DEFAULT VALUES: size of region to oversample - 64 pixels mainlobe width factor - 2.6 sidelobe width factor - 20.0 maximum oversampling factor - 8 */ // Read metadata sprintf(szImage, "%s.img", szImg); meta = meta_read(szImage); lines = meta->general->line_count; samples = meta->general->sample_count; text = (char *) MALLOC(255*sizeof(char)); // Handle input and output file fpIn = FOPEN(szCrList, "r"); fpOut = FOPEN(szOut, "w"); fprintf(fpOut, "POINT TARGET ANALYSIS RESULTS\n\n"); fprintf(fpOut, "CR\tLat\tLon\tElev\tAz peak\tRng peak\tLook\t" "Az res\tRng res\tAz PSLR\tRng PSLR\tSCR\n"); // RCS needs some more coding // Loop through corner reflector location file while (fgets(buffer, 1000, fpIn)) { if (overwrite) { sscanf(buffer, "%s\t%lf\t%lf", crID, &posY, &posX); printf(" %s: posX = %.2lf, posY = %.2lf\n", crID, posX, posY); } else { sscanf(buffer, "%s\t%lf\t%lf\t%lf", crID, &lat, &lon, &elev); meta_get_lineSamp(meta, lat, lon, elev, &posY, &posX); printf(" %s: lat = %.4lf, lon = %.4lf, posX = %.2lf, posY = %.2lf\n", crID, lat, lon, posX, posY); } // Check bounds - Get average spectra from chip in range direction if (!(outOfBounds(posX, posY, srcSize))) { // READ SUBSET FROM THE IMAGE WITH CORNER REFLECTOR IN THE CENTER size = srcSize*srcSize*sizeof(float); original_amplitude = (float *) MALLOC(size); phase = (float *) MALLOC(size); s = (complexFloat *) MALLOC(2*size); readComplexSubset(szImage, srcSize, srcSize, posX-srcSize/2, posY-srcSize/2, s); my_complex2polar(s, srcSize, srcSize, original_amplitude, phase); if (debug) { // Store original image for debugging fp = FOPEN("original.img", "wb"); size = bigSize*bigSize*sizeof(float); FWRITE(original_amplitude, size, 1, fp); FCLOSE(fp); meta_debug = meta_init(szImage); meta_debug->general->line_count = meta_debug->general->sample_count = srcSize; meta_debug->general->data_type = REAL32; meta_debug->general->start_line = posY-srcSize/2; meta_debug->general->start_sample = posX-srcSize/2; meta_debug->general->center_latitude = lat; meta_debug->general->center_longitude = lon; meta_write(meta_debug, "original.meta"); meta_free(meta_debug); } // Find amplitude peak in original image chip if (!findPeak(original_amplitude, srcSize, &srcPeakX, &srcPeakY)) { fprintf(fpOut, " Could not find amplitude peak in original image chip!\n"); goto SKIP; } // Cut out the subset again around the peak to make sure we have data for // the analysis readComplexSubset(szImage, srcSize, srcSize, posX-srcSize+srcPeakY, posY-srcSize+srcPeakX, s); my_complex2polar(s, srcSize, srcSize, original_amplitude, phase); FREE(phase); findPeak(original_amplitude, srcSize, &srcPeakX, &srcPeakY); // Determine look angle look_angle = meta_look(meta, srcSize/2, srcSize/2); /**************************** - special ScanSAR case: images are "projected" - need to be rotated back to allow analysis in azimuth and range direction (ss_extract.c) *********************/ // BASEBAND THE DATA IN EACH DIMENSION IN THE FREQUENCY DOMAIN // Oversample image src_fft = forward_fft(s, srcSize, srcSize); trg_fft = oversample(src_fft, srcSize, oversampling_factor); // Determine azimuth and range window size azimuth_processing_bandwidth = (float) meta->sar->azimuth_processing_bandwidth; prf = (float) meta->sar->prf; chirp_rate = (float) meta->sar->chirp_rate; pulse_duration = (float) meta->sar->pulse_duration; sampling_rate = (float) meta->sar->range_sampling_rate; azimuth_window_size = azimuth_processing_bandwidth / prf; range_window_size = fabs(chirp_rate) * pulse_duration / sampling_rate; printf("azimuth window size: %.2f, range window size: %.2f\n", azimuth_window_size, range_window_size); asfRequire(azimuth_window_size > 0.0 && azimuth_window_size < 1.0, "azimuth window size out of range (0 to 1)!\n"); asfRequire(range_window_size > 0.0 && range_window_size < 1.0, "range window size out of range (0 to 1)!\n"); if (range_window_size < 0.5) range_window_size = 0.5; // for ScanSAR both 0.5 // run debugger to check units are correct! // Baseband image in range direction //baseband(src_fft, range_window_size); /* // Transpose matrix to work in azimuth direction //transpose(s); // Baseband image in azimuth direction // baseband(s, azimuth_window_size); // Transpose matrix back into original orientation //transpose(s); */ t = inverse_fft(trg_fft, bigSize, bigSize); amplitude = (float *) MALLOC(sizeof(float)*bigSize*bigSize); phase = (float *) MALLOC(sizeof(float)*bigSize*bigSize); my_complex2polar(t, bigSize, bigSize, amplitude, phase); FREE(phase); if (debug) { // Store oversampled image for debugging fp = FOPEN("oversample.img", "wb"); size = bigSize*bigSize*sizeof(float); FWRITE(amplitude, size, 1, fp); FCLOSE(fp); meta_debug = meta_init("oversample.meta"); meta_debug->general->line_count = meta_debug->general->sample_count = bigSize; meta_debug->general->data_type = REAL32; meta_write(meta_debug, "oversample.meta"); meta_free(meta_debug); } // Find the amplitude peak in oversampled image if (!findPeak(amplitude, bigSize, &bigPeakX, &bigPeakY)) { fprintf(fpOut, " Could not find amplitude peak in oversampled image chip!\n"); goto SKIP; } peak_line = (int)(bigPeakX + 0.5); peak_sample = (int)(bigPeakY + 0.5); // Write text version of oversampled image sprintf(text, "%s_%s_chip.txt", szImg, crID); fpText = FOPEN(text, "w"); for (ii=peak_line-32; ii<peak_line+32; ii++) { for (kk=peak_sample-32; kk<peak_sample+32; kk++) fprintf(fpText, "%12.4f\t", amplitude[ii*bigSize+kk]); fprintf(fpText, "\n"); } FCLOSE(fpText); // EXTRACTING PROFILES IN AZIMUTH AND RANGE THROUGH PEAK for (ii=0; ii<bigSize; ii++) { azimuth_profile[ii] = amplitude[ii*bigSize+peak_sample]; range_profile[ii] = amplitude[bigSize*peak_line+ii]; } sprintf(text, "%s_%s_azimuth.txt", szImg, crID); fp = FOPEN(text, "w"); fprintf(fp, "Azimuth profile\n"); for (ii=0; ii<bigSize; ii++) fprintf(fp, "%.3f\n", azimuth_profile[ii]); FCLOSE(fp); sprintf(text, "%s_%s_range.txt", szImg, crID); fp = FOPEN(text, "w"); fprintf(fp, "Range profile\n"); for (ii=0; ii<bigSize; ii++) fprintf(fp, "%.3f\n", range_profile[ii]); FCLOSE(fp); // FINALLY GET TO THE IMAGE QUALITY PARAMETERS clutter_power = 0.0; // Find main lobes in oversampled image if (!find_mainlobe(amplitude, azimuth_profile, bigSize, peak_line, clutter_power, &mainlobe_azimuth_min, &mainlobe_azimuth_max)) { fprintf(fpOut, " No mainlobes could be found for %s in azimuth!\n", crID); goto SKIP; } //printf("mainlobe azimuth: min = %d, max = %d\n", // mainlobe_azimuth_min, mainlobe_azimuth_max); if (!find_mainlobe(amplitude, range_profile, bigSize, peak_sample, clutter_power, &mainlobe_range_min, &mainlobe_range_max)) { fprintf(fpOut, " No mainlobes could be found for %s in range!\n", crID); goto SKIP; } //printf("mainlobe range: min = %d, max = %d\n", // mainlobe_range_min, mainlobe_range_max); // Calculate resolution in azimuth and range for profiles if (!calc_resolution(azimuth_profile, mainlobe_azimuth_min, mainlobe_azimuth_max, peak_line, meta->general->y_pixel_size, clutter_power, &azimuth_resolution)) fprintf(fpOut, " Negative azimuth resolution for %s - invalid result!" "\n", crID); //printf("azimuth resolution = %.2f\n", azimuth_resolution); if (!calc_resolution(range_profile, mainlobe_range_min, mainlobe_range_max, peak_sample, meta->general->x_pixel_size, clutter_power, &range_resolution)) fprintf(fpOut, " Negative range resolution for %s - invalid result!\n", crID); //printf("range resolution = %.2f\n", range_resolution); // Find peak of original data - thought we had that already: check !!! // Calculate the clutter power azimuth_resolution /= meta->general->x_pixel_size; range_resolution /= meta->general->y_pixel_size; clutter_power = calc_clutter_power(original_amplitude, srcSize, peak_sample, peak_line, azimuth_resolution, range_resolution); //printf(" Clutter power: %8.3f\n", clutter_power); // Calculate resolution in azimuth and range with estimated clutter power if (!calc_resolution(azimuth_profile, mainlobe_azimuth_min, mainlobe_azimuth_max, peak_line, meta->general->y_pixel_size, clutter_power, &azimuth_resolution)) fprintf(fpOut, " Negative azimuth resolution for %s - invalid result!" "\n", crID); if (!calc_resolution(range_profile, mainlobe_range_min, mainlobe_range_max, peak_sample, meta->general->x_pixel_size, clutter_power, &range_resolution)) fprintf(fpOut, " Negative range resolution for %s - invalid result!\n", crID); //printf(" Azimuth resolution: %.3f\n", azimuth_resolution); //printf(" Range resolution: %.3f\n", range_resolution); // Find sidelobes in oversampled image and calculate the point-to-sidelobe // ratio in azimuth and range direction if (find_sidelobe(azimuth_profile, bigSize, 1, peak_line, mainlobe_azimuth_max, &sidelobe_azimuth_max) && find_sidelobe(azimuth_profile, bigSize, -1, peak_line, mainlobe_azimuth_min, &sidelobe_azimuth_min)) { if (!calc_pslr(azimuth_profile, bigSize, peak_line, sidelobe_azimuth_min, sidelobe_azimuth_max, &azimuth_pslr)) //printf(" Azimuth PSLR: %.3f\n", azimuth_pslr); //printf(" No valid PSLR in azimuth could be determined!\n"); ; } else { fprintf(fpOut, " Problem in finding sidelobes for %s in azimuth - " "invalid PSLR!\n", crID); } if (find_sidelobe(range_profile, bigSize, 1, peak_sample, mainlobe_range_max, &sidelobe_range_max) && find_sidelobe(range_profile, bigSize, -1, peak_sample, mainlobe_range_min, &sidelobe_range_min)) { if (!calc_pslr(range_profile, bigSize, peak_sample, sidelobe_range_min, sidelobe_range_max, &range_pslr)) //printf(" Range PSLR: %.3f\n", range_pslr); //printf(" No valid PSLR in range could be determined!\n"); ; } else { fprintf(fpOut, " Problem in finding sidelobes for %s in range -" " invalid PSLR!\n", crID); } //printf("sidelobe_azimuth: min = %d, max = %d\n", // sidelobe_azimuth_min, sidelobe_azimuth_max); //printf("sidelobe_range: min = %d, max = %d\n", // sidelobe_range_min, sidelobe_range_max); // Calculate the signal-to-clutter ratio (SCR) peak_power = amplitude[peak_line*bigSize+peak_sample] * amplitude[peak_line*bigSize+peak_sample]; if (clutter_power>0 && peak_power>clutter_power) scr = 10 * log((peak_power - clutter_power)/clutter_power); else scr = 0.0; if (peak_power > 0.0) { peak_power = 10 * log(peak_power); //printf(" Peak power: %.3f\n", peak_power); //printf(" SCR: %.3f\n", scr); } else fprintf(fpOut, " Negative peak power - invalid result!\n"); FREE(amplitude); FREE(original_amplitude); // Write values in output files fprintf(fpOut, "%s\t%.4lf\t%.4lf\t%.1lf\t%.1lf\t%.1f\t%.3f\t" "%.3f\t%.3f\t%.3f\t%.3f\t%.3f\n", crID, lat, lon, elev, posX-srcSize+srcPeakY, posY-srcSize+srcPeakX, look_angle*R2D, azimuth_resolution, range_resolution, azimuth_pslr, range_pslr, scr); SKIP: continue; } else fprintf(fpOut, "\n WARNING: Target %s outside the image boundaries!\n", crID); } FCLOSE(fpIn); FCLOSE(fpOut); FREE(meta); return(0); }