https://github.com/HartmutBorth/PLASIM
Tip revision: ea4d2d8d11d8b4c8de2ed947f3362f3932e620c3 authored by Frank on 28 June 2017, 14:13:41 UTC
Frank 28.06.17:
Frank 28.06.17:
Tip revision: ea4d2d8
most.c
/*
MOST - Model Starter
---------------------------------------------------------------------------
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
---------------------------------------------------------------------------
*/
#include <ctype.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <unistd.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xatom.h>
#include <X11/keysym.h>
#include <X11/XKBlib.h>
#define INT int
#define LINEMAX 256
typedef char String[LINEMAX];
String Buffer;
#ifndef MIN
#define MIN(a,b) ((a) < (b) ? (a) : (b))
#endif
#ifndef MAX
#define MAX(a,b) ((a) > (b) ? (a) : (b))
#endif
#define FULLARC (360 * 64)
#define WINDOW_WIDTH 820
/* Models */
#define PUMA 0
#define SAM 1
#define CAT 2
#define PLASIM 3
#define MODELS 4
/* Resolutions */
#define RES_T15 0
#define RES_T21 1
#define RES_T31 2
#define RES_T42 3
#define RES_T63 4
#define RESOLUTIONS 5
int PlasimSteps[RESOLUTIONS] =
{
60, // T15
45, // T21
30, // T31
20, // T42
10 // T63
};
int PumaSteps[RESOLUTIONS] =
{
60, // T15
60, // T21
45, // T31
30, // T42
15 // T63
};
int ResLat[RESOLUTIONS] =
{
24,
32,
48,
64,
96
};
int Resolution = -1;
char *ShortModelName[MODELS] =
{
"puma",
"sam",
"cat",
"plasim"
};
char *FullModelName[MODELS] =
{
"PUMA",
"SAM",
"CAT",
"Planet Simulator"
};
int Model = PUMA;
#define ALL -1
#define EARTH 0
#define MARS 1
#define EXO 2
#define PLANETS 3
char *PlanetName[PLANETS] =
{
"Earth",
"Mars",
"Exo"
};
int Planet = EARTH;
double *OroEarth; // Earth Orography T42 (128 x 64)
double *OroMars; // Mars Orography T42 (128 x 64)
double *OroPrep; // Preprocessed Orography
Pixmap OpmEarth;
Pixmap OpmMars;
Pixmap OpmPrep;
double RevGra = 1.0 / 9.81;
/* Object types */
#define SEL_TEXT 1
#define SEL_CHECK 2
#define SEL_INT 3
#define SEL_REAL 4
#define SEL_TEVA 5
#define SEL_PLANET 6
struct ItemStruct
{
char list[80]; // Name of namelist
char name[80]; // Name of variable
char text[80]; // Text value
float pvec[PLANETS]; // Planetary parameter
double rval; // Real value
int ival; // Integer value
int model; // Model
int flag; // Flag
};
struct SelStruct
{
struct SelStruct *Next; // Link to next Sel
struct SelStruct *Prev; // Link to previous Sel
struct ItemStruct *Item; // Link to item
int type; // Type (TEXT,CHECK,INT,REAL)
int x; // x coordinate of box
int y; // y coordinate of box
int h; // height of box
int w; // width of box
int xo; // x offset
int xt; // x coordinate for text
int yt; // y coordinate for text
int lt; // length of text
int iv; // integer value of box content
int div; // default integer value
int no; // 1: not selectable
int teco; // text colour
int edco; // edit column (cursor)
int hide; // 1: don't show
float fv; // floating value of box content
float dfv; // default floating value
float fpl[PLANETS]; // planet dependent floats
int *piv; // pointer to linked integer variable
float *pfv; // pointer to linked float variable
char text[80]; // text to display
char teva[16]; // box content
};
struct SelStruct SelStart;
struct SelStruct SelModels[MODELS];
struct SelStruct *CursorSel;
struct SelStruct *ComEnd;
struct SelStruct *SelAno;
struct SelStruct *SelTgr;
struct SelStruct *SelOro;
struct SelStruct *SelMod;
struct SelStruct *SelRes;
struct SelStruct *SelOce;
struct SelStruct *SelLsg;
struct SelStruct *SelIce;
struct SelStruct *SelAnn;
struct SelStruct *SelPlanet[PLANETS];
struct SelStruct *SelSYear;
struct SelStruct *SelCPU;
struct SelStruct *SelMulti;
struct SelStruct *SelLat2;
// Title lines for the entry of resolution
char *DimText1;
char *DimText2;
char *DimText3;
#define DIMLOGO 4
struct SymbolStruct
{
int x; // x pos
int y; // y pos
int w; // width
int h; // height
int b; // background color
int f; // foreground color
char **i; // image
char *d; // image data
XImage *X; // X-Image
char t[2][80]; // caption
} Logo[DIMLOGO];
int Logos;
struct ColorStrip
{
double Lo;
double Hi;
char *Name;
unsigned long pixel;
};
unsigned long WinBG = 0; // Black background
unsigned long TextC = 0; // Text color
unsigned long HeadC = 0; // Heading color
#define DIMFRAME 3
int Frames;
struct FrameStruct
{
void (*Action)();
Pixmap pixmap; // pixmap
int x; // x pos
int y; // y pos
int w; // width
int h; // height
int b; // background color
int f; // foreground color
int xs; // x pos selection
int ys; // y pos selection
int ws; // width selection
int hs; // height selection
char t[3][80]; // text
} Frame[DIMFRAME];
int FrameNo;
int Buttons;
int Button1Down = 1;
#define DIMBUTTON 5
struct ButtonStruct
{
void (*Action)();
int x; // x pos
int y; // y pos
int w; // width
int h; // height
int b; // background color
int f; // foreground color
char t[3][80]; // text
} Button[DIMBUTTON];
int Buttons;
/* Coordinates */
int opbox_x;
int opbox_y;
int opbox_w;
int opbox_h;
int nlbox_x;
int nlbox_y;
int nlbox_w;
int nlbox_h;
int nlpos_x;
int nledi_x;
int sfbox_x;
int sfbox_y;
int sfbox_w;
int sfbox_h;
int sfbox_b;
int bubox_x;
int bubox_y;
int bubox_w;
int bubox_h;
int CursorCol;
int LastSel;
int EdiKeyCode;
#define NL_MAX_ITEMS 100
int NL_items = 0;
struct ItemStruct NL_list[NL_MAX_ITEMS];
int BigEndian;
int Oce;
int Ice;
int Lsg;
int SimStart;
int SimYears;
int nreadsr;
int noutput;
int ndebug;
int nprec;
int ngui;
int noro = 1;
int OroAno;
int OroClear;
int OroAqua;
int TgrAno;
int nac;
int Preprocessed;
int SAMindex;
int ScreenHeight;
int Expert = 1;
int CatEnabled;
int SamEnabled;
int LsgEnabled;
int ModeRadiusSq;
int ForceRebuild;
int dxsh;
int dxs2;
int Yoden; // PUMA setup for Yoden experiment
int CatSim = 51; // simulation setup number for CAT
/* Special parameter */
int Latitudes = 32; // Number of latitudes in atmosphere
int Latitude2 = 32; // Number of latitudes for 2nd. instance
int Levels = 10; // Number of levels in atmosphere
int Cores = 1; // Number of cores for parallel version
int Multirun = 1; // Number of coupled runs
int MultirunEnabled = 0; // Multirun module present?
int Truncation = 21; // Spectral truncation computed from Latitudes
unsigned Seed;
char cfg_file[256] = "most_last_used.cfg";
char exec_name[256] = "most_puma.x";
char exec_nam2[256] = "most_puma.x"; // 2nd. instance
char exec_ppp[256] = "most_ppp.x";
char oro_name[256] = "N064_surf_0129.sra"; // Orography in T42 resolution
char namelist_name[256] = "puma_namelist";
char diag_name[256] = "puma_diag";
char outp_name[256] = "puma_output";
char build_name[256] = "most_puma_build";
char build_ppp[256] = "most_ppp_build";
char run_name[256] = "most_puma_run";
char run_ppp[256] = "most_ppp_run";
char res_name[256] = "resmod.f90";
char hostname[256] = "localhost";
char mpirun[256] = "mpirun"; // "openmpirun" for Open MPI
int ScreenN;
time_t CurrentDate;
Display *display;
unsigned int ScreenW,ScreenH;
int SmallScreen = 1;
static char *progname = "Most";
int DimX;
int DimY;
int DimTr = 21;
int DimSH = 11 * 23;
int DimSE = 11 * 23 + 2;
int ScreenD;
int OffX;
int OffY = 0;
int WinXSize;
int WinYSize;
int WhitePix;
int BlackPix;
int *Ampli;
int *ModeX;
int *ModeY;
int *ModeM;
int *ModeN;
Colormap colormap;
XColor xcolor1,xcolor2;
XColor Red,Green,Blue,Grey,LightRed,DarkRed,LightBlue,DarkBlue;
XColor LightGreen,DarkGreen,Yellow,Cyan,Dummy;
Window Cow; // Control bar
XTextProperty WinconName1;
XEvent WinEvent;
XSizeHints CowSizeHints;
int count;
XEvent report;
GC gc;
char ModFontName[80] = "-misc-fixed-bold-r-normal--15-*-*-*-*-*-*-*";
char FixFontName[80] = "-misc-fixed-bold-r-normal--15-*-*-*-*-*-*-*";
char BigFontName[80] = "-misc-fixed-medium-r-normal--20-*-*-*-*-*-*-*";
//char ModFontName[80] = "9x15bold";
//char FixFontName[80] = "9x15bold";
//char BigFontName[80] = "10x20";
XFontStruct *ModFont;
XFontStruct *FixFont;
XFontStruct *BigFont;
XFontStruct *SamFont;
int ModFontHeight;
int FixFontHeight;
int BigFontHeight;
int ModFontWidth;
int FixFontWidth;
int BigFontWidth;
int ModFontAscent;
int FixFontAscent;
int BigFontAscent;
int EdiFirstKey;
int EdiLastKey;
int EdiSymsPerKey;
int NumLockMask;
int ModeSwitchMask;
int Debug = 0;
KeySym *EdiKeymap;
XModifierKeymap *Mok;
char *display_name = NULL;
XWMHints wm_hints;
XClassHint class_hints;
Atom Delwin;
char *mona[12] =
{
"Jan","Feb","Mar",
"Apr","May","Jun",
"Jul","Aug","Sep",
"Oct","Nov","Dec"
};
char datch[32];
struct MapImageStruct
{
char *d; // Bitmap data
int w; // Image width
int h; // Image height
int f; // Rotation factor
float l; // Reference longitude
float r; // Rotation speed [deg/step]
XImage *X; // XImage structure
};
struct MapImageStruct MapHRE; // Hires (2560x1280) Earth image
struct MapImageStruct MapHRM; // Hires ( ) Mars image
struct MapImageStruct MapLRE; // Lores azimuthal Earth image
struct MapImageStruct MapLRM; // Lores azimuthal Mars image
struct MapImageStruct MapLRK; // Lores azimuthal Kepler-16
struct MapImageStruct MapLRL; // Lores azimuthal Kepler-186b
/* Isoarea data */
#define TOLELO 0x0001
#define TOLEHI 0x0002
#define TORILO 0x0004
#define TORIHI 0x0008
#define BOLELO 0x0010
#define BOLEHI 0x0020
#define BORILO 0x0040
#define BORIHI 0x0080
#define TOLEIN 0x0100
#define TOREIN 0x0200
#define BOLEIN 0x0400
#define BOREIN 0x0800
#define IPX(l,m,h) (VGAX * (x + (l-m) / (l-h)))
#define IPY(l,m,h) (VGAY * (y + (l-m) / (l-h)))
int nlon = 128;
int nlat = 64;
int nlev = 5;
int *Flag;
double VGAX;
double VGAY;
Pixmap pix;
/* Orography units are [m2/s2] */
struct ColorStrip OroStrip[] =
{
{-99999.0, 80.0,"DarkBlue"},
{ 80.0, 800.0,"green"},
{ 800.0, 1600.0,"brown"},
{ 1600.0, 2400.0,"orange"},
{ 2400.0,99999.0,"white"},
{ 0.0, 0.0,NULL}
};
struct ColorStrip OroMarsStrip[] =
{
{-99999.0,-16000.0,"yellow"},
{-16000.0,-12000.0,"RoyalBlue4"},
{-12000.0, -8000.0,"RoyalBlue3"},
{ -8000.0, -4000.0,"RoyalBlue2"},
{ -4000.0, 0.0,"RoyalBlue1"},
{ 0.0, 4000.0,"dark green"},
{ 4000.0, 8000.0,"light green"},
{ 8000.0, 12000.0,"brown"},
{ 12000.0, 16000.0,"orange"},
{ 16000.0, 99999.0,"white"},
{ 0.0, 0.0,NULL}
};
struct ColorStrip GibbStrip[] =
{
{-99999.0, 0.0,"DarkBlue"},
{ 0.0,99999.0,"green"},
{ 0.0, 0.0,NULL}
};
struct ColorStrip TStrip[] =
{
{-99.0,-15.0,"RoyalBlue4"},
{-15.0,-20.0,"RoyalBlue3"},
{-10.0, -5.0,"RoyalBlue2"},
{ -5.0, -0.1,"RoyalBlue1"},
{ -0.1, 0.1,"yellow"},
{ 0.1, 5.0,"IndianRed1"},
{ 5.0, 10.0,"IndianRed2"},
{ 10.0, 15.0,"IndianRed3"},
{ 15.0, 20.0,"IndianRed4"},
{ 20.0,999.0,"red"},
{ 0.0, 0.0,NULL}
};
void DoNothing(void)
{
printf("Do nothing\n");
}
void ChangeModel(int NewMo)
{
int i;
struct SelStruct *Sel;
if (NewMo < 0) // locate active model
{
NewMo = PUMA; // default if none is specified
for (i=0 , Sel = SelMod ; i < MODELS; ++i , Sel = Sel->Next)
{
if (Sel->iv == 1) NewMo = i;
}
}
ComEnd->Next = &SelModels[NewMo];
ComEnd->Next->Prev = ComEnd;
for (i=0 , Sel = SelMod ; i < MODELS; ++i , Sel = Sel->Next)
{
if (i == NewMo) Sel->iv = 1;
else Sel->iv = 0;
}
if (NewMo == PUMA || NewMo == SAM)
{
SelAno->hide = 0;
SelAnn->no = 0;
SelOce->no = 1;
SelIce->no = 1;
SelOro->no = 0;
SelSYear->no = 1;
if (SelLsg) SelLsg->no = 1;
for (i=0 ; i < PLANETS ; ++i) SelPlanet[i]->no = 1;
}
if (NewMo == PLASIM)
{
SelAno->hide = 1;
SelAnn->no = 1;
SelOro->no = 1;
SelSYear->no = 0;
if (Expert)
{
SelOce->no = 0;
SelIce->no = 0;
if (SelLsg) SelLsg->no = 0;
for (i=0 ; i < PLANETS ; ++i) SelPlanet[i]->no = 0;
}
}
if (Expert)
{
if (NewMo == CAT)
{
strcpy(DimText1,"NGX ");
strcpy(DimText2,"NGY ");
}
else
{
strcpy(DimText1,"Latitudes #1 ");
strcpy(DimText2,"Latitudes #2 ");
}
}
else
{
if (NewMo == CAT)
{
strcpy(DimText1,"[ 64 x 64 ]");
strcpy(DimText2,"[ 256 x 256 ]");
strcpy(DimText3,"[1024 x 1024]");
}
else
{
strcpy(DimText1,"T21 [64x32]");
strcpy(DimText2,"T31 [96x48]");
strcpy(DimText3,"T42 [128x64]");
}
}
Model = NewMo;
}
void WriteSettings(void)
{
int mxtl;
char tb[80];
FILE *fp;
struct SelStruct *Sel;
fp = fopen("most_last_used.cfg","w");
if (!fp) return;
fprintf(fp,"[MoSt 17 - configuration file] created %s\n",ctime(&CurrentDate));
mxtl = 0;
for (Sel = &SelStart ; Sel ; Sel = Sel->Next)
{
if (Sel->type != SEL_TEXT ) mxtl = MAX(mxtl,strlen(Sel->text));
}
for (Sel = &SelStart ; Sel ; Sel = Sel->Next)
{
if (Sel->type == SEL_TEXT ) fprintf(fp,"\n[%s]\n",Sel->text);
else
{
memset(tb,' ',sizeof(tb));
strncpy(tb,Sel->text,strlen(Sel->text));
tb[mxtl] = 0;
fprintf(fp,"%s = ",tb);
}
if (Sel->type == SEL_CHECK) fprintf(fp,"%6d\n",Sel->iv);
else if (Sel->type == SEL_INT ) fprintf(fp,"%6d\n",Sel->iv);
else if (Sel->type == SEL_TEVA ) fprintf(fp,"%s\n",Sel->teva);
else if (Sel->type == SEL_REAL || Sel->type == SEL_PLANET)
{
if (Sel->type == SEL_PLANET) Sel->fv = Sel->fpl[Planet];
if (fabs(Sel->fv) >= 1.0 && fabs(Sel->fv) < 9000.0) fprintf(fp,"%10.4f\n",Sel->fv);
else fprintf(fp,"%10.4e\n",Sel->fv);
}
}
fclose(fp);
}
void FormatReal(float fv, char *text)
{
if (fv == 0.0 ||
(fv > 0.001 && fv < 99999.0) ||
(fv > -9999.0 && fv < -0.001))
{
sprintf(text,"%11.4f",fv);
if (!strcmp(text+8,"000")) text[ 8] = 0;
else if (!strcmp(text+9,"00" )) text[ 9] = 0;
else if (text[10] == '0') text[10] = 0;
}
else
{
sprintf(text,"%11.4e",fv);
}
}
void UpdateSelections(struct SelStruct *Sel)
{
char text[80];
int selx;
selx = 0;
for (; Sel ; Sel = Sel->Next)
{
if (Sel == ComEnd->Next) selx = 1;
if (selx) Sel->x = nledi_x;
if (Sel->type == SEL_INT )
{
sprintf(text,"%10d",Sel->iv);
strcpy(Sel->teva,text+10-Sel->edco);
if (Sel->piv) *Sel->piv = Sel->iv;
}
if (Sel->type == SEL_REAL || Sel->type == SEL_PLANET)
{
if (Sel->type == SEL_PLANET) Sel->fv = Sel->fpl[Planet];
FormatReal(Sel->fv,text);
strcpy(Sel->teva,text);
}
}
// if (SelLat2) SelLat2->no = (SelMulti->iv != 2) ;
}
void ChangePlanet(int NewPlanet)
{
struct SelStruct *Sel;
SelPlanet[Planet]->iv = 0;
Planet = NewPlanet;
SelPlanet[Planet]->iv = 1;
strcpy(SelModels[PLASIM].text,PlanetName[Planet]);
SelModels[PLASIM].lt = strlen(PlanetName[Planet]);
for (Sel = &SelStart ; Sel ; Sel = Sel->Next)
{
if (Sel->type == SEL_PLANET)
{
Sel->fv = Sel->fpl[Planet];
}
}
UpdateSelections(ComEnd->Next);
}
int ReadSettings(char *fn)
{
int pl;
char tb[80];
char *eq;
FILE *fp;
struct SelStruct *Sel;
fp = fopen(fn,"r");
if (!fp)
{
printf("\nUsing default configuration\n");
return 0;
}
fgets(tb,sizeof(tb),fp);
if (strncmp(tb,"[MoSt",5))
{
printf("\nFileheader is: %s\n",tb);
printf("Expected : [MoSt ...]\n");
printf("Using default configuration\n");
fclose(fp);
return 0;
}
while (!feof(fp))
{
eq = strchr(tb,'=');
if (eq)
{
for (Sel = &SelStart ; Sel ; Sel = Sel->Next)
{
if (!strncmp(tb,Sel->text,strlen(Sel->text)))
{
if (!isalnum(tb[strlen(Sel->text)]))
{
if (Sel->type == SEL_REAL || Sel->type == SEL_PLANET)
{
Sel->fv = atof(eq+1);
if (Sel->pfv) *Sel->pfv = Sel->fv;
if (Sel->type == SEL_PLANET) Sel->fpl[Planet] = Sel->fv;
}
else
{
Sel->iv = atoi(eq+1);
if (Sel->piv) *Sel->piv = Sel->iv;
}
}
}
}
}
else if (!strncmp(tb,"[Modules]",9)) ChangeModel(-1);
else
{
for (pl=0 ; pl < PLANETS ; ++pl)
{
if (!strncmp(tb+1,PlanetName[pl],strlen(PlanetName[pl])) && pl != Planet)
ChangePlanet(pl);
}
}
fgets(tb,sizeof(tb),fp);
}
fclose(fp);
return 1;
}
void Exit(void)
{
int i;
WriteSettings();
// XNextEvent(display,&WinEvent);
// XCloseDisplay(display);
exit(0);
}
void AbortMessage(char *s)
{
printf("\n\n%s\n",s);
exit(1);
}
void Abort(void)
{
Exit();
}
void InitNextSelection(struct SelStruct *Sel, int dy, char *t)
{
Sel->type = Sel->Prev->type;
Sel->y = Sel->Prev->y + dy;
Sel->h = Sel->Prev->h;
Sel->w = Sel->Prev->w;
Sel->xo = Sel->Prev->xo;
Sel->yt = Sel->Prev->yt + dy;
strcpy(Sel->text,t);
Sel->lt = strlen(Sel->text);
Sel->teco = Sel->Prev->teco;
Sel->edco = Sel->Prev->edco;
}
void CursorOn(void)
{
int x,y,w,h;
if (CursorSel)
{
x = CursorSel->x + CursorCol * FixFontWidth;
y = CursorSel->y;
w = CursorSel->w;
h = CursorSel->h;
XSetForeground(display,gc,Red.pixel);
XDrawRectangle(display,Cow,gc,x,y,FixFontWidth,h);
XDrawRectangle(display,Cow,gc,x-1,y-1,FixFontWidth+2,h+2);
}
}
void RemoveBlanks(char *p)
{
int l;
l = strlen(p);
while (l && p[l-1] == ' ') p[--l] = 0;
}
struct SelStruct *NewSel(struct SelStruct *OldSel)
{
struct SelStruct *Sel;
Sel = calloc(1,sizeof(struct SelStruct));
OldSel->Next = Sel;
Sel->Prev = OldSel;
return Sel;
}
void NL_i(int m, char *list, char *name, int i)
{
if (NL_items > NL_MAX_ITEMS-2)
{
printf("\n*** Error ***\n");
printf("Number of namelist items exceeds %d \n",NL_MAX_ITEMS);
printf("Increase NL_MAX_ITEMS in most,c\n");
exit(1);
}
NL_list[NL_items].model = m;
strcpy(NL_list[NL_items].list,list);
strcpy(NL_list[NL_items].name,name);
NL_list[NL_items].flag = SEL_INT;
NL_list[NL_items].ival = i;
NL_list[NL_items].rval = 0.0;
NL_list[NL_items].text[0] = 0;
NL_items++;
}
void NL_r(int m, char *list, char *name, double r)
{
if (NL_items > NL_MAX_ITEMS-2)
{
printf("\n*** Error ***\n");
printf("Number of namelist items exceeds %d \n",NL_MAX_ITEMS);
printf("Increase NL_MAX_ITEMS in most,c\n");
exit(1);
}
NL_list[NL_items].model = m;
strcpy(NL_list[NL_items].list,list);
strcpy(NL_list[NL_items].name,name);
NL_list[NL_items].flag = SEL_REAL;
NL_list[NL_items].ival = 0;
NL_list[NL_items].rval = r;
NL_list[NL_items].text[0] = 0;
NL_items++;
}
void NL_p(char *name, float r[])
{
if (NL_items > NL_MAX_ITEMS-2)
{
printf("\n*** Error ***\n");
printf("Number of namelist items exceeds %d \n",NL_MAX_ITEMS);
printf("Increase NL_MAX_ITEMS in most,c\n");
exit(1);
}
NL_list[NL_items].model = PLASIM;
strcpy(NL_list[NL_items].list,"planet");
strcpy(NL_list[NL_items].name,name);
NL_list[NL_items].flag = SEL_PLANET;
NL_list[NL_items].ival = 0;
NL_list[NL_items].rval = 0.0;
NL_list[NL_items].text[0] = 0;
memcpy(NL_list[NL_items].pvec,r,sizeof(float) * PLANETS);
NL_items++;
}
void NL_t(int m, char *list, char *name, char *t)
{
if (NL_items > NL_MAX_ITEMS-2)
{
printf("\n*** Error ***\n");
printf("Number of namelist items exceeds %d \n",NL_MAX_ITEMS);
printf("Increase NL_MAX_ITEMS in most,c\n");
exit(1);
}
NL_list[NL_items].model = m;
strcpy(NL_list[NL_items].list,list);
strcpy(NL_list[NL_items].name,name);
NL_list[NL_items].flag = SEL_TEVA;
NL_list[NL_items].ival = 0;
NL_list[NL_items].rval = 0.0;
strcpy(NL_list[NL_items].text,t);
NL_items++;
}
// Earth Mars Exo
float eccen_vec[PLANETS] = { 0.016715, 0.09341233, 0.0};
float mvelp_vec[PLANETS] = { 102.7 , 336.04084 , 0.0};
float obliq_vec[PLANETS] = { 23.44 , 25.19 , 0.0};
float gsol0_vec[PLANETS] = {1367.0 , 595.0 ,1000.0};
void InitNamelist(void)
{
// Planet Simulator
NL_p("ECCEN" , eccen_vec);
NL_p("MVELP" , mvelp_vec);
NL_p("OBLIQ" , obliq_vec);
NL_p("GSOL0" , gsol0_vec);
NL_i(PLASIM,"planet" ,"NFIXORB" , 0);
NL_r(PLASIM,"radmod" ,"CO2" ,360.0);
NL_i(PLASIM,"plasim" ,"KICK" , 1);
NL_i(PLASIM,"plasim" ,"MPSTEP" , 0);
NL_i(PLASIM,"plasim" ,"NAQUA" , 0);
NL_i(PLASIM,"plasim" ,"NDIAG" , 0);
NL_i(PLASIM,"plasim" ,"NGUIDBG" , 0);
NL_i(PLASIM,"plasim" ,"NQSPEC" , 1);
NL_i(PLASIM,"plasim" ,"NVEG" , 0);
NL_i(PLASIM,"plasim" ,"NWPD" , 1);
NL_i(PLASIM,"plasim" ,"NPRINT" , 0);
NL_i(PLASIM,"plasim" ,"NSYNC" , 1);
NL_i(PLASIM,"rainmod","NCLOUDS" , 1);
NL_i(PLASIM,"rainmod","NSTORAIN", 0);
NL_r(PLASIM,"plasim" ,"SYNCSTR", 0.0);
// SAM
NL_i(SAM,"sam","KICK" , 1);
NL_i(SAM,"sam","NAFTER" , 24);
NL_i(SAM,"sam","NDEL" , 8);
NL_i(SAM,"sam","NDIAG" ,240);
NL_i(SAM,"sam","NEXP" , 4);
NL_i(SAM,"sam","NGUIDBG", 0);
NL_i(SAM,"sam","NTSPD" , 0);
NL_r(SAM,"sam","DISP" ,0.0);
NL_r(SAM,"sam","ROTSPD" ,1.0);
// PUMA
NL_i(PUMA,"puma","KICK" , 1);
NL_i(PUMA,"puma","MPSTEP" , 0);
NL_i(PUMA,"puma","NDEL" , 6);
NL_i(PUMA,"puma","NDHEAT" , 0);
NL_i(PUMA,"puma","NDIAG" , 0);
NL_i(PUMA,"puma","NEWSR" , 0);
NL_i(PUMA,"puma","NGUIDBG", 0);
NL_i(PUMA,"puma","NHELSUA", 0);
NL_i(PUMA,"puma","NSYNC" , 0);
NL_i(PUMA,"puma","NWPD" , 1);
NL_r(PUMA,"puma","DTEP" , 60);
NL_r(PUMA,"puma","DTNS" ,-70.0);
NL_r(PUMA,"puma","DTROP" , 12000.0);
NL_r(PUMA,"puma","DTTRP" , 2.0);
NL_r(PUMA,"puma","SYNCSTR", 0.0);
NL_r(PUMA,"puma","ROTSPD" , 1.0);
NL_r(PUMA,"puma","TGR" , 288.0);
// CAT
NL_r(CAT,"cat","ALPHA" , 0.0);
NL_r(CAT,"cat","BETA" , 0.0);
NL_r(CAT,"cat","AFORC" , 0.001);
NL_r(CAT,"cat","TFORC" , 0.01);
NL_i(CAT,"cat","NFORC" , 0);
NL_i(CAT,"cat","NGUIDBG" , 0);
NL_i(CAT,"cat","NPOST" , 0);
NL_i(CAT,"cat","NSIM" , 0);
NL_i(CAT,"cat","KFMIN" , 0);
NL_i(CAT,"cat","KFMAX" , 8);
NL_i(CAT,"cat","JACMTHD" , 1);
NL_i(CAT,"cat","NSTEPS" , 10000);
}
void NamelistSelector(int model)
{
int i,yn,n,ml;
struct SelStruct *Sel;
int ledi_x,lbox_w,lbox_h;
yn = opbox_y;
n = 0;
ml = 0;
Sel = &SelModels[model];
if (model == PLASIM)
{
Sel->type = SEL_TEXT;
Sel->teco = HeadC;
Sel->y = opbox_y;
Sel->xt = nlpos_x;
Sel->yt = Sel->y + BigFontAscent + 1;
strcpy(Sel->text,PlanetName[Planet]);
Sel->lt = strlen(Sel->text);
yn += BigFontHeight + 1;
Sel = NewSel(Sel);
}
for (i=0 ; i < NL_items ; ++i)
if (NL_list[i].model == model)
{
Sel->Item = NL_list + i;
strcpy(Sel->text,NL_list[i].name);
Sel->lt = strlen(Sel->text);
Sel->type = NL_list[i].flag;
Sel->teco = BlackPix;
Sel->h = FixFontHeight + 1;
Sel->y = yn;
Sel->xt = nlpos_x;
Sel->yt = Sel->y + FixFont->ascent + 1;
if (Sel->lt > ml) ml = Sel->lt;
if (Sel->lt > ml) ml = Sel->lt;
if (NL_list[i].flag == SEL_INT)
{
Sel->w = 6 * FixFontWidth + 2;
Sel->edco = 6;
Sel->div = Sel->iv = NL_list[i].ival;
}
else if (NL_list[i].flag == SEL_REAL)
{
Sel->edco = 11;
Sel->w = 11 * FixFontWidth + 2;
Sel->dfv = Sel->fv = NL_list[i].rval;
}
else if (NL_list[i].flag == SEL_PLANET)
{
Sel->edco = 11;
Sel->w = 11 * FixFontWidth + 2;
Sel->dfv = Sel->fv = NL_list[i].pvec[Planet];
memcpy(Sel->fpl,NL_list[i].pvec,sizeof(float) * PLANETS);
}
else
{
Sel->edco = 11;
Sel->w = 11 * FixFontWidth + 2;
strncpy(Sel->teva,NL_list[i].text,15);
}
yn += FixFontHeight + 1;
Sel = NewSel(Sel);
++n;
}
Sel->Prev->Next = NULL; // Mark end of chain
/* Compute size of namelist box */
ledi_x = nlpos_x + (ml + 1) * FixFontWidth;
lbox_w = (ml + 14) * FixFontWidth;
lbox_h = BigFontHeight + (n+2) * FixFontHeight;
if (nledi_x < ledi_x) nledi_x = ledi_x;
if (nlbox_w < lbox_w) nlbox_w = lbox_w;
if (nlbox_h < lbox_h) nlbox_h = lbox_h;
UpdateSelections(ComEnd->Next);
}
void LoadFonts(void)
{
if (ScreenH < 700)
{
strcpy(ModFontName,"5x8");
strcpy(FixFontName,"6x10");
strcpy(BigFontName,"7x13");
}
else if (ScreenH < 800)
{
strcpy(ModFontName,"6x10");
strcpy(FixFontName,"7x13");
strcpy(BigFontName,"9x15bold");
}
if ((ModFont = XLoadQueryFont(display,ModFontName)) == NULL)
{
printf("%s: Cannot open %s font\n",progname,ModFontName);
exit(-1);
}
if ((FixFont = XLoadQueryFont(display,FixFontName)) == NULL)
{
printf("%s: Cannot open %s font\n",progname,FixFontName);
exit(-1);
}
if ((BigFont = XLoadQueryFont(display,BigFontName)) == NULL)
{
printf("%s: Cannot open %s font\n",progname,BigFontName);
exit(-1);
}
SamFont = XLoadQueryFont(display,"rk24");
ModFontWidth = XTextWidth(ModFont,"X",1);
FixFontWidth = XTextWidth(FixFont,"X",1);
BigFontWidth = XTextWidth(BigFont,"X",1);
FixFontAscent = FixFont->ascent;
ModFontAscent = ModFont->ascent;
BigFontAscent = BigFont->ascent;
ModFontHeight = ModFont->ascent + ModFont->descent;
FixFontHeight = FixFont->ascent + FixFont->descent;
BigFontHeight = BigFont->ascent + BigFont->descent;
if (Debug)
{
printf("ModFont %2d x %2d %s\n",ModFontWidth,ModFontHeight,ModFontName);
printf("FixFont %2d x %2d %s\n",FixFontWidth,FixFontHeight,FixFontName);
printf("BigFont %2d x %2d %s\n",BigFontWidth,BigFontHeight,BigFontName);
}
}
void InitSelections(void)
{
int i,l,n,dyn,dys,mw,x,dx;
char text[80];
struct SelStruct *Sel;
struct tm *dati;
FILE *fp;
opbox_x = FixFontWidth / 2;
dyn = FixFontHeight + 1;
dys = (3 * dyn) / 2;
// Initialize Sel at anchor SelStart
Sel = &SelStart;
// Model
Sel->type = SEL_TEXT;
Sel->teco = HeadC;
Sel->y = opbox_y;
Sel->yt = Sel->y + BigFontAscent + 1;
strcpy(Sel->text,"Model");
Sel->lt = strlen(Sel->text);
// PUMA
Sel = NewSel(Sel);
InitNextSelection(Sel,BigFontHeight,FullModelName[PUMA]);
Sel->type = SEL_CHECK;
Sel->teco = BlackPix;
Sel->h = FixFontHeight + 1;
Sel->w = FixFontHeight + 1;
Sel->yt = Sel->y + FixFontAscent + 1;
Sel->div = Sel->iv = 1;
SelMod = Sel;
// SAM
Sel = NewSel(Sel);
InitNextSelection(Sel,dyn,"SAM");
// Hide SAM ?
if (!SamEnabled)
{
Sel->no = 1;
Sel->lt = 0;
}
// CAT
Sel = NewSel(Sel);
InitNextSelection(Sel,dyn,FullModelName[CAT]);
// Hide CAT until released
if (!CatEnabled)
{
Sel->no = 1;
Sel->lt = 0;
}
// Planet Simulator
Sel = NewSel(Sel);
InitNextSelection(Sel,dyn,FullModelName[PLASIM]);
// Earth
Sel = NewSel(Sel);
InitNextSelection(Sel,dyn,"Earth");
SelPlanet[EARTH] = Sel;
Sel->div = Sel->iv = 1;
Sel->no = 1;
Sel->xo = (5 * FixFontWidth) / 2;
// Mars
Sel = NewSel(Sel);
InitNextSelection(Sel,dyn,"Mars");
SelPlanet[MARS] = Sel;
Sel->no = 1;
// Exo
Sel = NewSel(Sel);
InitNextSelection(Sel,dyn,"Exo");
SelPlanet[EXO] = Sel;
Sel->no = 1;
// Modules
Sel = NewSel(Sel);
InitNextSelection(Sel,dys,"Modules");
Sel->type = SEL_TEXT;
Sel->teco = HeadC;
Sel->h = 0;
Sel->w = 0;
Sel->yt = Sel->y + BigFontAscent + 1;
Sel->xo = 0;
// Mixed Layer Ocean
Sel = NewSel(Sel);
InitNextSelection(Sel,BigFontHeight,"ML Ocean");
Sel->type = SEL_CHECK;
Sel->teco = BlackPix;
Sel->h = FixFontHeight + 1;
Sel->w = FixFontHeight + 1;
Sel->yt = Sel->y + FixFontAscent + 1;
Sel->div = Sel->iv = 0;
Sel->no = 1;
SelOce = Sel;
Sel->piv = &Oce;
// LSG Ocean
if (LsgEnabled)
{
Sel = NewSel(Sel);
InitNextSelection(Sel,FixFontHeight,"LSG Ocean");
Sel->yt = Sel->y + FixFontAscent + 1;
Sel->div = Sel->iv = 0;
Sel->no = 1;
SelLsg = Sel;
Sel->piv = &Lsg;
}
// Ice
Sel = NewSel(Sel);
InitNextSelection(Sel,FixFontHeight,"Sea Ice");
Sel->type = SEL_CHECK;
Sel->teco = BlackPix;
Sel->h = FixFontHeight + 1;
Sel->w = FixFontHeight + 1;
Sel->yt = Sel->y + FixFontAscent + 1;
Sel->div = Sel->iv = 0;
Sel->no = 1;
SelIce = Sel;
Sel->piv = &Ice;
// Hardware
Sel = NewSel(Sel);
InitNextSelection(Sel,dys,"Parallelism");
Sel->type = SEL_TEXT;
Sel->teco = HeadC;
Sel->h = 0;
Sel->w = 0;
Sel->yt = Sel->y + BigFontAscent + 1;
// Number of CPUs
Sel = NewSel(Sel);
InitNextSelection(Sel,dys,"Cores");
Sel->h = FixFontHeight + 1;
Sel->w = FixFontHeight + 1;
Sel->yt = Sel->y + FixFont->ascent + 1;
Sel->w = 4 * FixFontWidth + 2;
Sel->type = SEL_INT;
Sel->edco = 4;
Sel->div = Sel->iv = Cores;
Sel->piv = &Cores;
SelCPU = Sel;
fp = fopen("most_compiler_mpi","r");
if (fp) fclose(fp);
else Sel->no = 1;
// Number of synchronous runs
if (MultirunEnabled && Expert)
{
Sel = NewSel(Sel);
InitNextSelection(Sel,dys,"Instances");
Sel->h = FixFontHeight + 1;
Sel->w = FixFontHeight + 1;
Sel->yt = Sel->y + FixFont->ascent + 1;
Sel->w = 4 * FixFontWidth + 2;
Sel->type = SEL_INT;
Sel->edco = 4;
Sel->div = Sel->iv = Multirun;
Sel->piv = &Multirun;
SelMulti = Sel;
fp = fopen("most_compiler_mpi","r");
if (fp) fclose(fp);
else Sel->no = 1;
}
// Resolution
Sel = NewSel(Sel);
InitNextSelection(Sel,dys,"Resolution");
Sel->type = SEL_TEXT;
Sel->h = 0;
Sel->w = 0;
Sel->yt = Sel->y + BigFont->ascent + 1;
// Horizontal resolution
if (Expert)
{
Sel = NewSel(Sel);
InitNextSelection(Sel,dys,"Latitudes #1");
Sel->h = FixFontHeight + 1;
Sel->yt = Sel->y + FixFont->ascent + 1;
Sel->w = 4 * FixFontWidth + 2;
Sel->edco = 4;
Sel->type = SEL_INT;
Sel->div = Sel->iv = Latitudes;
Sel->piv = &Latitudes;
DimText1 = Sel->text;
Sel = NewSel(Sel);
InitNextSelection(Sel,dys,"Latitudes #2");
Sel->div = Sel->iv = Latitudes;
Sel->piv = &Latitude2;
SelLat2 = Sel;
DimText2 = Sel->text;
}
else
{
Sel = NewSel(Sel);
InitNextSelection(Sel,dys,"T21 [64x32]");
Sel->type = SEL_CHECK;
Sel->h = FixFontHeight + 1;
Sel->w = FixFontHeight + 1;
Sel->yt = Sel->y + FixFont->ascent + 1;
Sel->div = Sel->iv = 1;
SelRes = Sel;
DimText1 = Sel->text;
Sel = NewSel(Sel);
InitNextSelection(Sel,dyn,"T31 [96x48]");
Sel->type = SEL_CHECK;
Sel->h = FixFontHeight + 1;
Sel->w = FixFontHeight + 1;
Sel->div = Sel->iv = 0;
DimText2 = Sel->text;
Sel = NewSel(Sel);
InitNextSelection(Sel,dyn,"T42 [128x64]");
Sel->type = SEL_CHECK;
Sel->h = FixFontHeight + 1;
Sel->w = FixFontHeight + 1;
Sel->div = Sel->iv = 0;
DimText3 = Sel->text;
}
// Vertical resolution
if (Expert)
{
Sel = NewSel(Sel);
InitNextSelection(Sel,dys,"Levels");
Sel->type = SEL_INT;
Sel->div = Sel->iv = Levels;
Sel->piv = &Levels;
}
// Options
Sel = NewSel(Sel);
InitNextSelection(Sel,dys,"Options");
Sel->type = SEL_TEXT;
Sel->h = 0;
Sel->w = 0;
Sel->yt = Sel->y + BigFont->ascent + 1;
// Global debug switch
Sel = NewSel(Sel);
InitNextSelection(Sel,dys,"Debug mode");
Sel->type = SEL_CHECK;
Sel->h = FixFontHeight + 1;
Sel->w = FixFontHeight + 1;
Sel->yt = Sel->y + FixFont->ascent + 1;
Sel->div = Sel->iv = 0;
Sel->piv = &ndebug;
// Precision switch
Sel = NewSel(Sel);
InitNextSelection(Sel,dyn,"Double Precision");
Sel->piv = ⊀
// Global output switch
Sel = NewSel(Sel);
InitNextSelection(Sel,dys,"Write Output");
Sel->type = SEL_CHECK;
Sel->h = FixFontHeight + 1;
Sel->w = FixFontHeight + 1;
Sel->yt = Sel->y + FixFont->ascent + 1;
Sel->div = Sel->iv = 0;
Sel->piv = &noutput;
// GUI
Sel = NewSel(Sel);
InitNextSelection(Sel,dyn,"Run with GUI");
Sel->type = SEL_CHECK;
Sel->h = FixFontHeight + 1;
Sel->w = FixFontHeight + 1;
Sel->div = Sel->iv = 1;
Sel->piv = &ngui;
// Orography
Sel = NewSel(Sel);
InitNextSelection(Sel,dyn,"Orography");
Sel->type = SEL_CHECK;
Sel->div = Sel->iv = 1;
Sel->piv = &noro;
SelOro = Sel;
// Annual cycle
Sel = NewSel(Sel);
InitNextSelection(Sel,dyn,"Annual cycle");
Sel->type = SEL_CHECK;
Sel->div = Sel->iv = 1;
SelAnn = Sel;
// Experiment
Sel = NewSel(Sel);
InitNextSelection(Sel,dys,"Simulation");
Sel->type = SEL_TEXT;
Sel->h = 0;
Sel->w = 0;
Sel->yt = Sel->y + BigFont->ascent + 1;
// Simulation Start
dati = localtime(&CurrentDate);
Sel = NewSel(Sel);
InitNextSelection(Sel,dys,"Start year");
Sel->h = FixFontHeight + 1;
Sel->yt = Sel->y + FixFont->ascent + 1;
Sel->w = 4 * FixFontWidth + 2;
Sel->edco = 4;
Sel->type = SEL_INT;
Sel->div = Sel->iv = 1;
Sel->piv = &SimStart;
SelSYear = Sel;
// Years
Sel = NewSel(Sel);
InitNextSelection(Sel,dyn,"Years to run");
Sel->h = FixFontHeight + 1;
Sel->yt = Sel->y + FixFont->ascent + 1;
Sel->w = 4 * FixFontWidth + 2;
Sel->type = SEL_INT;
Sel->div = Sel->iv = 10;
Sel->piv = &SimYears;
opbox_h = Sel->y + dys - opbox_y;
// Orography edit
Sel = NewSel(Sel);
InitNextSelection(Sel,dys,"Change [gpm]");
Sel->h = FixFontHeight + 1;
Sel->yt = Sel->y + FixFont->ascent + 1;
Sel->w = 6 * FixFontWidth + 2;
Sel->type = SEL_INT;
Sel->div = Sel->iv = 0;
Sel->piv = &OroAno;
SelAno = Sel;
// Ground temperature edit
/*
Sel = NewSel(Sel);
InitNextSelection(Sel,dys,"Change [K]");
Sel->h = FixFontHeight + 1;
Sel->yt = Sel->y + FixFont->ascent + 1;
Sel->w = 6 * FixFontWidth + 2;
Sel->type = SEL_INT;
Sel->div = Sel->iv = 0;
Sel->piv = &TgrAno;
SelTgr = Sel;
*/
// Mark end of common selection chain
ComEnd = Sel;
mw = 0;
for (Sel = &SelStart ; Sel ; Sel = Sel->Next)
if (Sel->w > mw) mw = Sel->w;
for (Sel = &SelStart ; Sel ; Sel = Sel->Next)
{
Sel->xt = Sel->xo + FixFontWidth * 2 + mw;
if (!Sel->x) Sel->x = Sel->xt - Sel->w - FixFontWidth;
if (Sel->type == SEL_INT )
{
sprintf(text,"%10d",Sel->iv);
strcpy(Sel->teva,text+10-Sel->edco);
}
}
for (x = 0 , Sel = &SelStart ; Sel ; Sel = Sel->Next)
{
if (Sel->type == SEL_TEXT) l = Sel->lt * BigFontWidth;
else l = Sel->lt * FixFontWidth;
if (x < l) x = l;
}
opbox_w = x + mw + 2 * FixFontWidth;
nlbox_x = opbox_x + opbox_w + FixFontWidth;
nlbox_y = opbox_y;
nlpos_x = nlbox_x + FixFontWidth;
}
void CheckMark(int x, int y, int d)
{
XSetForeground(display,gc,LightGreen.pixel);
XFillArc(display,Cow,gc,x+1,y+1,d-5,d-5,0,FULLARC);
}
void DisplayTeVa(int x, int y, int w, char *t)
{
int l;
l = strlen(t);
if (l > w / FixFontWidth) l = w / FixFontWidth;
XSetForeground(display,gc,WhitePix);
XSetBackground(display,gc,BlackPix);
if (l) XDrawImageString(display,Cow,gc,x,y,t,l);
}
void ShowSelection(struct SelStruct *Sel)
{
int x,y,h,w;
if (Sel->hide) return;
h = Sel->h;
w = Sel->w;
x = Sel->x;
y = Sel->y;
if (!Sel->no)
{
if (Sel->type == SEL_CHECK)
{
XSetForeground(display,gc,TextC);
XDrawArc(display,Cow,gc,x,y,w-2,h-2,0,FULLARC);
if (Sel->iv) CheckMark(x,y,w+1);
}
else DisplayTeVa(x+1,Sel->yt,w,Sel->teva);
}
XSetForeground(display,gc,TextC);
XSetBackground(display,gc,WinBG);
if (Sel->type == SEL_TEXT)
{
XSetFont(display, gc, BigFont->fid);
XSetForeground(display,gc,Sel->teco);
XDrawImageString(display,Cow,gc,Sel->xt,Sel->yt,Sel->text,Sel->lt);
XSetFont(display, gc, FixFont->fid);
}
else
XDrawImageString(display,Cow,gc,Sel->xt,Sel->yt,Sel->text,Sel->lt);
}
void InitLogo(void)
{
int n;
// KlimaCampus
n = 0;
Logo[n].x = FixFontWidth;
Logo[n].y = 8;
// PUMA
++n;
strcpy(Logo[n].t[0],FullModelName[PUMA]);
// Plasim
++n;
strcpy(Logo[n].t[0],FullModelName[PLASIM]);
// Cat
++n;
strcpy(Logo[n].t[0],FullModelName[CAT]);
Logos = n+1;
}
void GenerateNames(void)
{
Truncation = (2 * Latitudes - 1) / 3;
sprintf(namelist_name,"%s_namelist",ShortModelName[Model]);
if (Model == CAT)
{
if (Cores < 2) strcpy(exec_name,"most_cat.x");
else strcpy(exec_name,"most_cat_mpi.x");
}
else if (Model == PUMA)
{
if (Cores < 2) strcpy(exec_name,"most_puma.x");
else strcpy(exec_name,"most_puma_mpi.x");
}
else if (Model == SAM)
{
if (Cores < 2) strcpy(exec_name,"most_sam.x");
else strcpy(exec_name,"most_sam_mpi.x");
}
else
sprintf(exec_name,"most_%s_t%d_l%d_p%d.x",
ShortModelName[Model],Truncation,Levels,Cores);
sprintf(diag_name,"%s_diag",ShortModelName[Model]);
sprintf(outp_name,"%s_output",ShortModelName[Model]);
sprintf(build_name,"most_%s_build",ShortModelName[Model]);
sprintf(build_ppp,"most_%s_build","ppp");
sprintf(run_name,"most_%s_run",ShortModelName[Model]);
if (Latitudes < 1000) sprintf(oro_name,"N%3.3d_surf_0129.sra",Latitudes);
else sprintf(oro_name,"N%d_surf_0129.sra",Latitudes);
}
int WriteRunScript(int model)
{
int i;
int porm;
FILE *fp;
char command[256];
char run[256];
strcpy(exec_nam2,exec_name); // Duplicate exec name
if (model == CAT) // Add Dimensions
{
sprintf(exec_name+strlen(exec_name)," %d %d",Latitudes,Latitude2);
}
if (model == PUMA) // Add Latitudes and Levels as arguments
{
sprintf(exec_name+strlen(exec_name)," %d %d",Latitudes,Levels);
sprintf(exec_nam2+strlen(exec_nam2)," %d %d",Latitude2,Levels);
}
if (model == SAM) // Add Latitudes as arguments
{
sprintf(exec_name+strlen(exec_name)," %d",Latitudes);
sprintf(exec_nam2+strlen(exec_nam2)," %d",Latitude2);
}
// porm is for Parallel OR Multiprocessing
porm = MAX(Cores,Multirun);
strcpy(run,ShortModelName[model]);
strcat(run,"/run/");
strcat(run,run_name);
fp = fopen(run,"w");
if (fp == NULL)
{
printf("Could not open file <%s> for writing\n",run);
return 0; /* Failure */
}
fputs("#!/bin/bash\n",fp);
fprintf(fp,"# run-script generated by Most %s",ctime(&CurrentDate));
fputs("EXP=MOST # Name your experiment here\n",fp);
fprintf(fp,"[ $# == 1 ] && cd $1\n");
fprintf(fp,"rm -f %s_restart\n",ShortModelName[model]);
fputs("rm -f Abort_Message\n",fp);
fputs("YEAR=0\n",fp);
fprintf(fp,"YEARS=%d\n",SimYears);
if (Multirun > 1) fprintf(fp,"INSTANCES=%d\n",Multirun);
if (ngui) fputs("# Remove '#' from 'while' and 'end' lines for restart loop\n",fp);
if (ngui) fputs("# ",fp); /* deactivate loop for GUI case */
fputs("while [ $YEAR -lt $YEARS ]\n",fp);
if (ngui) fputs("# ",fp); /* deactivate loop for GUI case */
fputs("do\n",fp);
fputs(" YEAR=`expr $YEAR + 1`\n",fp);
fputs(" DATANAME=`printf '%s.%03d' $EXP $YEAR`\n",fp);
fputs(" DIAGNAME=`printf '%s_DIAG.%03d' $EXP $YEAR`\n",fp);
fputs(" RESTNAME=`printf '%s_REST.%03d' $EXP $YEAR`\n",fp);
if (porm < 2)
{
fprintf(fp," ./%s\n",exec_name);
}
else
{
if (Multirun > 1)
{
fprintf(fp," %s",mpirun);
fprintf(fp," -np 1 %s : -np 1 %s\n",exec_name,exec_nam2);
}
else
{
fprintf(fp," %s -np %d %s\n",mpirun,porm,exec_name);
}
}
fputs(" [ -e Abort_Message ] && exit 1\n",fp);
if (Multirun > 1)
{
fputs(" INST=0\n",fp);
fputs(" while [ $INST -lt $INSTANCES ]\n do\n",fp);
fputs(" EXT=`printf '%02d' $INST`\n",fp);
fprintf(fp," [ -e %s_$EXT ] && mv %s_$EXT ${EXT}_$DATANAME\n",
outp_name,outp_name);
fprintf(fp," mv %s_$EXT ${EXT}_$DIAGNAME\n",diag_name);
fprintf(fp," cp %s_status_$EXT %s_restart_$EXT\n",
ShortModelName[model],ShortModelName[model]);
fprintf(fp," mv %s_status_$EXT ${EXT}_$RESTNAME\n",ShortModelName[model]);
fputs(" INST=`expr $INST + 1`\n",fp);
fputs(" done\n",fp);
}
else
{
fprintf(fp," [ -e %s ] && mv %s $DATANAME\n",outp_name,outp_name);
fprintf(fp," [ -e %s ] && mv %s $DIAGNAME\n",diag_name,diag_name);
fprintf(fp," [ -e %s_status ] && cp %s_status %s_restart\n",
ShortModelName[model],ShortModelName[model],ShortModelName[model]);
fprintf(fp," [ -e %s_status ] && mv %s_status $RESTNAME\n",
ShortModelName[model],ShortModelName[model]);
}
if (ngui) fputs("# ",fp); /* deactivate loop for GUI case */
fputs("done\n",fp);
fclose(fp);
sprintf(command,"chmod a+x %s",run);
system(command);
return 1; /* Success */
}
void BlueMessage(char *mess)
{
int l,x,y,w,h;
XSetFont(display, gc, FixFont->fid);
l = strlen(mess);
w = FixFontWidth * (l + 4);
h = FixFontHeight * 3;
if (w > WinXSize) w = WinXSize;
XSetForeground(display,gc,Blue.pixel);
x = (WinXSize - w) / 2;
y = (WinYSize - h) / 2;
XFillRectangle(display,Cow,gc,x,y,w,h);
XSetForeground(display,gc,WhitePix);
XSetBackground(display,gc,Blue.pixel);
XDrawRectangle(display,Cow,gc,x-1,y-1,w+1,h+1);
x += 2 * FixFontWidth;
y += 2 * FixFontHeight;
XDrawImageString(display,Cow,gc,x,y,mess,l);
XSync(display,0);
}
void RedMessage(char *mess)
{
int l,x,y,w,h;
XSetFont(display, gc, FixFont->fid);
l = strlen(mess);
w = FixFontWidth * (l + 4);
h = FixFontHeight * 3;
if (w > WinXSize) w = WinXSize;
XSetForeground(display,gc,Red.pixel);
x = (WinXSize - w) / 2;
y = (WinYSize - h) / 2;
XFillRectangle(display,Cow,gc,x,y,w,h);
XSetForeground(display,gc,WhitePix);
XSetBackground(display,gc,Red.pixel);
XDrawRectangle(display,Cow,gc,x-1,y-1,w+1,h+1);
x += 2 * FixFontWidth;
y += 2 * FixFontHeight;
XDrawImageString(display,Cow,gc,x,y,mess,l);
XSync(display,0);
}
int WriteRunPPP(void)
{
int i;
FILE *fp;
char command[256];
char run[256];
strcpy(run,ShortModelName[Model]);
strcat(run,"/run/");
strcat(run,run_ppp);
fp = fopen(run,"w");
if (fp == NULL)
{
printf("Could not open file <%s> for writing\n",run);
return 0; /* Failure */
}
fputs("#!/bin/bash\n",fp);
fprintf(fp,"# run-script generated by Most %s",ctime(&CurrentDate));
fputs("[ $# == 1 ] && cd $1\n",fp);
if (OroClear) fprintf(fp,"rm -f %s\n",oro_name);
else if (!OroAqua)
fprintf(fp,"[ ! -e %s -a -e ../dat/%s ] && cp -p ../dat/%s .\n",
oro_name,oro_name,oro_name);
fprintf(fp," ./%s >!ppp.out\n",exec_ppp);
fclose(fp);
sprintf(command,"chmod a+x %s",run);
system(command);
strcpy(command,run);
BlueMessage("Running PUMA Preprocessor");
sprintf(command,"%s/run/%s %s/run",ShortModelName[Model],run_ppp,ShortModelName[Model]);
system(command);
OroAno = 0; /* Anomaly applied -> reset it */
SelAno->iv = 0;
return 1; /* Success */
}
void WriteResmod(char *res)
{
FILE *fp;
int OldLat,OldLev,OldPro;
char Line[80];
// Read existing file if there and check for changes
fp = fopen(res,"r");
if (fp)
{
fgets(Line,80,fp); // header line 1
fgets(Line,80,fp); // header line 2
fgets(Line,80,fp);
OldLat = atoi(Line+27);
fgets(Line,80,fp);
OldLev = atoi(Line+27);
fgets(Line,80,fp);
OldPro = atoi(Line+27);
fclose(fp);
if (OldLat == Latitudes && OldLev == Levels && OldPro == Cores) return;
}
fp = fopen(res,"w");
if (fp == NULL)
{
printf("Could not open file <%s> for writing\n",res);
exit(1); /* Failure */
}
fprintf(fp," module resmod ! generated by MoSt %s\n",ctime(&CurrentDate));
fprintf(fp," parameter(NLAT_ATM = %d)\n",Latitudes);
fprintf(fp," parameter(NLEV_ATM = %d)\n",Levels);
fprintf(fp," parameter(NPRO_ATM = %d)\n",Cores);
fprintf(fp," end module resmod\n");
fclose(fp);
}
int Build(int model)
{
int i,l,x,y,ierr;
int porm;
FILE *fp;
char script_backup[256];
char command[256];
char message[256];
char bld[256];
char res[256];
char *shomo;
porm = MAX(Cores,Multirun);
shomo = ShortModelName[model];
strcpy(bld,shomo);
strcat(bld,"/bld/");
strcpy(res,bld);
strcat(bld,build_name);
strcat(res,res_name);
strcpy(script_backup,bld);
strcat(script_backup,".bak");
rename(bld,script_backup);
if (model == PLASIM) WriteResmod(res);
fp = fopen(bld,"w");
if (fp == NULL)
{
printf("Could not open file <%s> for writing\n",bld);
return 0; /* Failure */
}
fputs("#!/bin/bash\n",fp);
fprintf(fp,"# compile-script generated by Most %s",ctime(&CurrentDate));
fputs("[ $# == 1 ] && cd $1\n",fp);
if (ForceRebuild) fputs("rm -f *.x *.o *.mod\n",fp);
fputs("cp -p ../src/* .\n",fp);
if (ngui == 0) // Use stub routines and switch off X11 lib
{
putenv("GUIMOD=guimod_stub");
putenv("PUMAX=pumax_stub");
putenv("GUIX11=guix11_stub");
putenv("GUILIB=");
}
if (Planet == MARS) putenv("PLAMOD=p_mars");
if (Planet == EXO ) putenv("PLAMOD=p_exo");
if (Lsg)
{
fputs("cp -p ../../lsg/src/lsgmod.f90 .\n",fp);
putenv("OCEANCOUP=cpl");
}
else
{
putenv("OCEANCOUP=cpl_stub");
}
if (Latitudes < 4) putenv("FFTMOD=fft991mod");
if (porm > 1)
{
fputs("[ ! -e MPI ] && rm -f *.o *.mod *.x\n",fp);
fputs("touch MPI\n",fp);
fputs("cat ../../most_compiler_mpi",fp);
if (Multirun > 1) putenv("MPIMOD=mpimod_multi");
}
else
{
fputs("[ -e MPI ] && rm -f *.o *.mod *.x MPI\n",fp);
fputs("cat ../../most_compiler",fp);
}
if (ndebug) fputs(" ../../most_debug_options",fp);
if (nprec)
{
fputs(" ../../most_precision_options",fp);
}
fprintf(fp," make_%s > makefile\n",shomo);
fputs("make -e\n",fp);
fprintf(fp,"[ $? == 0 ] && cp %s.x ../bin/%s\n",shomo,exec_name);
fclose(fp);
sprintf(command,"chmod a+x %s",bld);
system(command);
sprintf(message,"Building %s - wait a minute!",FullModelName[Model]);
BlueMessage(message);
strcat(bld," ");
strcat(bld,shomo);
strcat(bld,"/bld");
if (system(bld))
{
RedMessage("Error in build process");
sleep(5);
return 0; // error
}
sprintf(command,"cp %s/bin/%s %s/run\n",shomo,exec_name,shomo);
system(command);
// copy CAT simulation namelist to run directory
if (model == CAT)
{
sprintf(command,"cp cat/dat/sim_%4.4d.nl cat/run/sim_namelist\n",CatSim);
system(command);
}
// copy hires background bitmap for Earth or Mars
if (model == PUMA || model == PLASIM )
{
if (model == PLASIM && Planet == MARS)
{
sprintf(command,"cp images/mars.bmp %s/run/map.bmp\n",shomo);
system(command);
}
else if (model == PLASIM && Planet == EARTH)
{
sprintf(command,"cp images/earth.bmp %s/run/map.bmp\n",shomo);
system(command);
}
}
// copy surface data in matching resolution to run directory
if (model == PLASIM)
{
if (Planet == MARS)
sprintf(command,"cp plasim/dat/T%d_mars/* plasim/run/\n",Truncation);
else if (Planet == EXO)
sprintf(command,"cp plasim/dat/T%d_exo/* plasim/run/\n",Truncation);
else
sprintf(command,"cp plasim/dat/T%d/* plasim/run/\n",Truncation);
system(command);
if (Lsg) // copy data for LSG ocean model and select LSG GUI configuration
{
sprintf(command,"cp lsg/dat/* %s/run\n",shomo);
system(command);
sprintf(command,"cp %s/dat/GUI_LSG.cfg %s/run/GUI.cfg\n",shomo,shomo);
system(command);
}
else
{
sprintf(command,"cp %s/dat/GUI.cfg %s/run\n",shomo,shomo);
system(command);
}
}
else
{
sprintf(command,"cp %s/dat/GUI.cfg %s/run\n",shomo,shomo);
system(command);
}
// copy second GUI configuration for two-instances run
if (Multirun > 1)
{
sprintf(command,"cp %s/dat/GUI_0?.cfg %s/run\n",shomo,shomo);
system(command);
}
return 1; /* Success */
}
int BuildPPP(void)
{
int i,l,x,y;
FILE *fp;
char script_backup[256];
char command[256];
char message[256];
char bld[256];
char res[256];
strcpy(bld,ShortModelName[Model]);
strcat(bld,"/bld/");
strcpy(res,bld);
strcat(bld,build_ppp);
strcat(res,res_name);
strcpy(script_backup,bld);
strcat(script_backup,".bak");
rename(bld,script_backup);
fp = fopen(bld,"w");
if (fp == NULL)
{
printf("Could not open file <%s> for writing\n",bld);
return 0; /* Failure */
}
fputs("#!/bin/bash\n",fp);
fprintf(fp,"# compile-script generated by Most %s",ctime(&CurrentDate));
fputs("[ $# == 1 ] && cd $1\n",fp);
fputs("rm -f *.o *.mod\n",fp);
fputs("cp ../src/make_ppp .\n",fp);
fputs("cp ../src/*.f90 .\n",fp);
fputs("cat ../../most_compiler",fp);
if (ndebug) fputs(" ../../most_debug_options",fp);
if (nprec) fputs(" ../../most_precision_options",fp);
fprintf(fp," make_ppp > makefile_ppp\n");
fputs("make -e -f makefile_ppp\n",fp);
fprintf(fp,"cp ppp.x ../bin/%s\n",exec_ppp);
fclose(fp);
sprintf(command,"chmod a+x %s",bld);
system(command);
sprintf(command,"%s/bin/%s",ShortModelName[Model],exec_ppp);
if (!(fp = fopen(command,"r")))
{
sprintf(message,"Building preprocessor ppp");
BlueMessage(message);
strcat(bld," ");
strcat(bld,ShortModelName[Model]);
strcat(bld,"/bld");
system(bld);
}
else fclose(fp); // Executable exists already
sprintf(command,"cp %s/bin/%s %s/run\n",ShortModelName[Model],exec_ppp,ShortModelName[Model]);
system(command);
return 1; /* Success */
}
void FinishLine(void)
{
char text[80];
int OldCores;
OldCores = Cores;
if (CursorSel == NULL) return;
if (CursorSel->type == SEL_INT)
{
CursorSel->iv = atoi(CursorSel->teva);
sprintf(text,"%10d",CursorSel->iv);
strcpy(CursorSel->teva,text+10-CursorSel->edco);
if (CursorSel->piv) *CursorSel->piv = CursorSel->iv;
}
if (CursorSel->type == SEL_REAL)
{
CursorSel->fv = atof(CursorSel->teva);
FormatReal(CursorSel->fv,text);
strcpy(CursorSel->teva,text);
}
/*
if (CursorSel == SelMulti) // Enable or disable Lat2
{
SelLat2->no = (SelMulti->iv != 2) ;
}
*/
if (OldCores == 1 && Cores > 1) ForceRebuild = 1;
if (OldCores > 1 && Cores == 1) ForceRebuild = 1;
if (Model == PLASIM && OldCores != Cores) ForceRebuild = 1;
}
int CheckPumaNamelist(void)
{
int i,safe_ntspd;
int *ntspd;
int *nyoden = NULL;
double s;
struct SelStruct *Sel;
FILE *fp;
FinishLine();
for (Sel = &SelStart ; Sel ; Sel = Sel->Next)
{
if (Sel->piv) *Sel->piv = Sel->iv;
if (!strcmp(Sel->text,"NTSPD" )) ntspd = &Sel->iv;
if (!strcmp(Sel->text,"NYODEN" )) nyoden = &Sel->iv;
if (!strcmp(Sel->text,"Orography" )) nreadsr = Sel->iv;
if (!strcmp(Sel->text,"Annual cycle")) nac = Sel->iv;
}
// Check for resolution defines as T value
if (Resolution > 0) Latitudes = ResLat[Resolution];
// Check # of latitudes for correct values (FFT requirements)
/*
if (Latitudes >= 2048) Latitudes = 2048; // T1365
else if (Latitudes >= 1024) Latitudes = 1024; // T682
else if (Latitudes >= 512) Latitudes = 512; // T341
else if (Latitudes >= 256) Latitudes = 256; // T170
else if (Latitudes >= 192) Latitudes = 192; // T127
else if (Latitudes >= 160) Latitudes = 160; // T106
else if (Latitudes >= 128) Latitudes = 128; // T85
else if (Latitudes >= 96) Latitudes = 96; // T63
else if (Latitudes >= 64) Latitudes = 64; // T42
else if (Latitudes >= 48) Latitudes = 48; // T31
else if (Latitudes >= 32) Latitudes = 32; // T21
else if (Latitudes >= 24) Latitudes = 24; // T15
else Latitudes = 16; // T10
*/
if (Debug) printf("Latitudes = %d\n",Latitudes);
// Force # of levels to 20 for predefined Yoden profiles
if (nyoden && *nyoden > 0)
{
Levels = 20;
Yoden = *nyoden;
}
// Make sure # of CPU's is a power of 2 and in the proper range
if (Cores > Latitudes/2) Cores = Latitudes/2;
if (Cores < 1) Cores = 1;
if ((Latitudes/2) % Cores != 0) Cores = 1;
// Multirun is currently implemented for two runs only
if (Multirun >= 2)
{
Multirun = SelMulti->iv = 2;
Cores = SelCPU->iv = 1;
}
return 0; /* Success */
}
int CheckCATNamelist(void)
{
int i,safe_ntspd;
int *ntspd;
int *nyoden = NULL;
double s;
struct SelStruct *Sel;
FILE *fp;
FinishLine();
/*
for (Sel = &SelStart ; Sel ; Sel = Sel->Next)
{
if (Sel->piv) *Sel->piv = Sel->iv;
if (!strcmp(Sel->text,"NTSPD" )) ntspd = &Sel->iv;
if (!strcmp(Sel->text,"NYODEN" )) nyoden = &Sel->iv;
if (!strcmp(Sel->text,"Orography" )) nreadsr = Sel->iv;
if (!strcmp(Sel->text,"Annual cycle")) nac = Sel->iv;
}
*/
// Check for resolution
if (Resolution == 1)
Latitudes = Latitude2 = 64;
else if (Resolution == 2)
Latitudes = Latitude2 = 256;
else if (Resolution == 3)
Latitudes = Latitude2 = 1024;
if (Debug) printf("NGX = NGY = %d\n",Latitudes);
return 0; /* Success */
}
int CheckPlasimNamelist(void)
{
int i,safe_mpstep;
int *mpstep;
double s;
struct SelStruct *Sel;
FILE *fp;
FinishLine();
for (Sel = &SelStart ; Sel ; Sel = Sel->Next)
{
if (Sel->piv) *Sel->piv = Sel->iv;
if (!strcmp(Sel->text,"MPSTEP")) mpstep = &Sel->iv;
if (!strcmp(Sel->text,"Orography" )) nreadsr = Sel->iv;
if (!strcmp(Sel->text,"Annual cycle")) nac = Sel->iv;
}
// Check for resolution defines as T value
if (Resolution > 0) Latitudes = ResLat[Resolution];
// LSG works currently only with T21 PlaSim
if (Lsg)
{
Resolution = RES_T21;
Latitudes = ResLat[RES_T21];
}
// Check # of latitudes for correct values (FFT requirements)
if (Latitudes >= 64) Latitudes = 64; // T42
else if (Latitudes >= 48) Latitudes = 48; // T31
else if (Latitudes >= 32) Latitudes = 32; // T21
else if (Latitudes >= 4) Latitudes = 4; // T2
else if (Latitudes >= 2) Latitudes = 2; // T1
// Set mpstep to a safe value
if (Resolution > 0) *mpstep = PlasimSteps[Resolution];
else
{
s = log(Latitudes / 32.0) / log(2.0);
safe_mpstep = 45.0 / pow(3.0,s);
if (*mpstep > safe_mpstep) *mpstep = safe_mpstep;
}
// Make sure # of CPU's is a power of 2 and in the proper range
if (Cores > Latitudes) Cores = Latitudes;
if (Cores < 1) Cores = 1;
if (Latitudes % Cores != 0) Cores = 1;
return 0; /* Success */
}
double *ReadGrid(const char *fn, int klat, double Sc)
{
int i,j,k,jlev,iteml,gridsize;
FILE *ifp;
int head[8];
double *gp;
char Line[256];
char Elem[16];
nlat = klat;
nlon = nlat + nlat;
VGAX = (double)sfbox_w / nlon;
VGAY = (double)sfbox_h / (nlat-1);
gridsize = (nlon+1) * nlat * sizeof(double);
gp = malloc(gridsize);
ifp = fopen(fn,"r");
if (!ifp) return NULL;
fgets(Line,sizeof(Line),ifp);
for (i = 0 ; i < 8 ; ++i)
{
strncpy(Elem,Line+i*10,10);
Elem[10] = 0;
head[i] = atoi(Elem);
}
if (head[4] == nlon && head[5] == nlat)
{
for (j = 0 ; j < nlat ; ++j)
{
for (i = 0 ; i < nlon ; i+=8)
{
fgets(Line,sizeof(Line),ifp);
iteml = strlen(Line) / 8;
for (k=0 ; k < 8 ; ++k)
{
strncpy(Elem,Line+k*iteml,iteml);
Elem[iteml] = 0;
gp[k+i+j*(nlon+1)] = atof(Elem) * Sc;
}
}
gp[nlon+j*(nlon+1)] = gp[j*(nlon+1)];
}
}
else printf("head[4] = %d head[5] = %d\n",head[4],head[5]);
fclose(ifp);
return gp;
}
void WriteOroNamelist(FILE *fp)
{
int lon1,lon2,lat1,lat2;
double w,h;
w = Frame[0].w;
h = Frame[0].h;
// Round to next gridpoint
lon1 = 1 + (Frame[0].xs * Latitudes*2) / w;
lon2 = 1 +((Frame[0].xs + Frame[0].ws) * Latitudes*2) / w;
lat1 = 1 + (Frame[0].ys * Latitudes) / h;
lat2 = 1 +((Frame[0].ys + Frame[0].hs) * Latitudes) / h;
fprintf(fp," %-8s=%d\n","NSRV" , 0);
fprintf(fp," %-8s=%d\n","NORO" ,noro);
fprintf(fp," %-8s=%d\n","OROANO" ,OroAno);
fprintf(fp," %-8s=%d\n","LON1ORO",lon1);
fprintf(fp," %-8s=%d\n","LON2ORO",lon2);
fprintf(fp," %-8s=%d\n","LAT1ORO",lat1);
fprintf(fp," %-8s=%d\n","LAT2ORO",lat2);
fprintf(fp," %-8s=%d\n","TGRANO" ,TgrAno);
lon1 = 1 + (Frame[1].xs * Latitudes*2) / Frame[1].w;
lon2 = 1 +((Frame[1].xs + Frame[1].ws) * Latitudes*2) / Frame[1].w;
lat1 = 1 + (Frame[1].ys * Latitudes) / Frame[1].h;
lat2 = 1 +((Frame[1].ys + Frame[1].hs) * Latitudes) / Frame[1].h;
fprintf(fp," %-8s=%d\n","LON1TGR",lon1);
fprintf(fp," %-8s=%d\n","LON2TGR",lon2);
fprintf(fp," %-8s=%d\n","LAT1TGR",lat1);
fprintf(fp," %-8s=%d\n","LAT2TGR",lat2);
return; /* Success */
}
void WriteResolutionNamelist(void)
{
int i;
char nln[256];
FILE *fp;
for (i = 0 ; i < Multirun ; ++i)
{
sprintf(nln,"%s/run/resolution_namelist",ShortModelName[Model]);
if (Multirun > 1) sprintf(nln+strlen(nln),"_%2.2d",i);
fp = fopen(nln,"w");
if (fp == NULL)
{
printf("Could not open file <%s> for writing\n",nln);
return; /* Failure */
}
fprintf(fp," &RES\n");
fprintf(fp," NLAT = %d\n" ,Latitudes);
if (Model != SAM) fprintf(fp," NLEV = %d\n" ,Levels);
fprintf(fp," /END\n");
fclose(fp);
}
}
/* ================= */
/* WritePumaNamelist */
/* ================= */
int WritePumaNamelist(void) /* also used for model SAM */
{
int i,j,k,sum,val,imr;
FILE *fp;
char backup_name[256];
char nln[256];
struct SelStruct *Sel;
FinishLine();
// Write file <puma_namelist> or <sam_namelist>
for (imr = 0 ; imr < Multirun ; ++imr)
{
strcpy(nln,ShortModelName[Model]);
strcat(nln,"/run/");
strcat(nln,namelist_name);
if (Multirun > 1) sprintf(nln+strlen(nln),"_%2.2d",imr);
fp = fopen(nln,"w");
if (fp == NULL)
{
printf("Could not open file <%s> for writing\n",nln);
return 0; /* Failure */
}
fprintf(fp," &%s_nl\n",ShortModelName[Model]);
if (Preprocessed || noro) nreadsr = 1;
fprintf(fp," %-8s=%6d\n","NOUTPUT" ,noutput);
fprintf(fp," %-8s=%6d\n","NGUI" ,ngui);
if (nac)
{
fprintf(fp," %-8s=%11.4f\n","TAC" ,360.0);
fprintf(fp," %-8s=%11.4f\n","PAC" , 0.0);
}
else
{
fprintf(fp," %-8s=%11.4f\n","TAC" , 0.0);
fprintf(fp," %-8s=%11.4f\n","PAC" , 0.0);
}
if (ngui) fprintf(fp," %-8s=%6d\n","NYEARS",SimYears);
else fprintf(fp," %-8s=%6d\n","NYEARS",1);
fprintf(fp," %-8s=%6d\n","NMONTHS",0);
for (Sel = ComEnd->Next ; Sel ; Sel = Sel->Next)
{
if (Sel->type == SEL_INT)
fprintf(fp," %-8s=%6d\n",Sel->text,Sel->iv);
if (Sel->type == SEL_REAL)
fprintf(fp," %-8s=%s\n",Sel->text,Sel->teva);
}
// Check for mode selections
for (i=0,sum=0 ; i < DimSH ; ++i) sum += Ampli[i];
if (sum != DimSH) // Some modes are off
{
fprintf(fp," NSPECSEL = ");
i = 0;
while (i < DimSH)
{
val = Ampli[i];
j = i;
while (j < DimSH && Ampli[j] == val) ++j;
k = j - i;
if (k == 1) fprintf(fp,"%d",val);
else fprintf(fp,"%d*%d",k,val);
if (j < DimSH) fprintf(fp,",");
i = j;
}
fprintf(fp,"\n");
}
fprintf(fp," /END\n");
fclose(fp);
}
return 1; /* Success */
}
/* ================ */
/* WriteCatNamelist */
/* ================ */
int WriteCatNamelist(void)
{
int i,j,k,sum,val;
FILE *fp;
char backup_name[256];
char nln[256];
struct SelStruct *Sel;
FinishLine();
// Write file <cat_namelist>
strcpy(nln,ShortModelName[Model]);
strcat(nln,"/run/");
strcat(nln,namelist_name);
fp = fopen(nln,"w");
if (fp == NULL)
{
printf("Could not open file <%s> for writing\n",nln);
return 0; /* Failure */
}
fprintf(fp," &%s_nl\n",ShortModelName[Model]);
fprintf(fp," %-8s=%6d\n","NGUI" ,ngui);
for (Sel = ComEnd->Next ; Sel ; Sel = Sel->Next)
{
if (Sel->type == SEL_INT)
fprintf(fp," %-8s=%6d\n",Sel->text,Sel->iv);
if (Sel->type == SEL_REAL)
fprintf(fp," %-8s=%s\n",Sel->text,Sel->teva);
if (!strncmp(Sel->text,"NSIM",4))
{
if (Sel->iv > 0) CatSim = Sel->iv;
}
}
fprintf(fp," /END\n");
fclose(fp);
return 1; /* Success */
}
/* ================ */
/* WritePPPNamelist */
/* ================ */
int WritePPPNamelist(void)
{
int i,j,k,sum,val;
FILE *fp;
char backup_name[256];
char nln[256];
struct SelStruct *Sel;
FinishLine();
WriteResolutionNamelist();
/* 2. Write file <ppp_namelist> */
strcpy(nln,ShortModelName[Model]);
strcat(nln,"/run/");
strcat(nln,"ppp_namelist");
strcpy(backup_name,nln);
strcat(backup_name,".bak");
rename(nln,backup_name);
fp = fopen(nln,"w");
if (fp == NULL)
{
printf("Could not open file <%s> for writing\n",nln);
return 0; /* Failure */
}
fprintf(fp," &ppp_nl\n");
if (Preprocessed || noro) nreadsr = 1;
fprintf(fp," %-8s=%d\n","NOUTPUT" ,noutput);
fprintf(fp," %-8s=%d\n","NGUI" ,ngui);
if (nac)
{
fprintf(fp," %-8s=%11.4f\n","TAC" ,360.0);
fprintf(fp," %-8s=%11.4f\n","PAC" , 0.0);
}
else
{
fprintf(fp," %-8s=%11.4f\n","TAC" , 0.0);
fprintf(fp," %-8s=%11.4f\n","PAC" , 0.0);
}
for (Sel = ComEnd->Next ; Sel ; Sel = Sel->Next)
{
if (Sel->type == SEL_INT)
fprintf(fp," %-8s=%6d\n",Sel->text,Sel->iv);
if (Sel->type == SEL_REAL)
fprintf(fp," %-8s=%s\n",Sel->text,Sel->teva);
}
WriteOroNamelist(fp);
fprintf(fp," /END\n");
fclose(fp);
return 1; /* Success */
}
/* ======== */
/* FillPoly */
/* ======== */
void FillPoly(int n, double Poly[])
{
int i;
XPoint xpol[8];
for (i=0; i < n ; ++i)
{
xpol[i].x = OffX + Poly[i+i ] + 0.5;
xpol[i].y = OffY + Poly[i+i+1] + 0.5;
}
XFillPolygon(display,pix,gc,xpol,n,Convex,CoordModeOrigin);
}
/* ======= */
/* IsoArea */
/* ======= */
void IsoArea(INT y, double vl, double vh, double Top[], double Bot[], INT Dim)
{
INT f,x,p;
double xl,xr,yt,yb;
double Poly[16];
for (x=0 ; x < Dim-1 ; x++)
{
Flag[x] = 0;
if (Top[x ] < vl) Flag[x] |= TOLELO;
if (Top[x ] >= vh) Flag[x] |= TOLEHI;
if (Top[x+1] < vl) Flag[x] |= TORILO;
if (Top[x+1] >= vh) Flag[x] |= TORIHI;
if (Bot[x ] < vl) Flag[x] |= BOLELO;
if (Bot[x ] >= vh) Flag[x] |= BOLEHI;
if (Bot[x+1] < vl) Flag[x] |= BORILO;
if (Bot[x+1] >= vh) Flag[x] |= BORIHI;
}
x = 0;
while (x < Dim-1)
{
xl = VGAX * x ;
xr = VGAX * (x+1);
yt = VGAY * y ;
yb = VGAY * (y+1);
f = Flag[x];
if (f == 0)
{
x++;
while (x < Dim-1 && Flag[x] == 0)
{
x++;
xr = VGAX * x;
}
Poly[0] = Poly[6] = xl;
Poly[1] = Poly[3] = yt;
Poly[2] = Poly[4] = xr;
Poly[5] = Poly[7] = yb;
FillPoly(4,Poly);
}
else if (f == (TOLELO | TORILO | BOLELO | BORILO) ||
f == (TOLEHI | TORIHI | BOLEHI | BORIHI)) x++;
else if (Top[x] < vl && Top[x+1] >= vl && Bot[x] >= vl && Bot[x+1] < vl)
{
Poly[1] = Poly[3] = yt;
Poly[2] = Poly[4] = xr;
Poly[0] = IPX(Top[x ],vl,Top[x+1]);
Poly[5] = IPY(Top[x+1],vl,Bot[x+1]);
FillPoly(3,Poly);
Poly[1] = Poly[3] = yb;
Poly[2] = Poly[4] = xl;
Poly[0] = IPX(Bot[x ],vl,Bot[x+1]);
Poly[5] = IPY(Top[x ],vl,Bot[x ]);
FillPoly(3,Poly);
++x;
}
else if (Top[x] >= vl && Top[x+1] < vl && Bot[x] < vl && Bot[x+1] >= vl)
{
Poly[0] = Poly[4] = xl;
Poly[1] = Poly[3] = yt;
Poly[2] = IPX(Top[x ],vl,Top[x+1]);
Poly[5] = IPY(Top[x ],vl,Bot[x ]);
FillPoly(3,Poly);
Poly[0] = Poly[2] = xr;
Poly[3] = Poly[5] = yb;
Poly[1] = IPY(Top[x+1],vl,Bot[x+1]);
Poly[4] = IPX(Bot[x ],vl,Bot[x+1]);
FillPoly(3,Poly);
++x;
}
else
{
p = 0;
if (Top[x] < vl)
{
if (Top[x+1] >= vl)
{
Poly[p++] = IPX(Top[x],vl,Top[x+1]);
Poly[p++] = yt;
}
if (Top[x+1] >= vh)
{
Poly[p++] = IPX(Top[x],vh,Top[x+1]);
Poly[p++] = yt;
}
}
else if (Top[x] >= vh)
{
if (Top[x+1] < vh)
{
Poly[p++] = IPX(Top[x],vh,Top[x+1]);
Poly[p++] = yt;
}
if (Top[x+1] < vl)
{
Poly[p++] = IPX(Top[x],vl,Top[x+1]);
Poly[p++] = yt;
}
}
else
{
Poly[p++] = xl;
Poly[p++] = yt;
if (Top[x+1] < vl)
{
Poly[p++] = IPX(Top[x],vl,Top[x+1]);
Poly[p++] = yt;
}
if (Top[x+1] >= vh)
{
Poly[p++] = IPX(Top[x],vh,Top[x+1]);
Poly[p++] = yt;
}
}
if (Top[x+1] < vl)
{
if (Bot[x+1] >= vl)
{
Poly[p++] = xr;
Poly[p++] = IPY(Top[x+1],vl,Bot[x+1]);
}
if (Bot[x+1] >= vh)
{
Poly[p++] = xr;
Poly[p++] = IPY(Top[x+1],vh,Bot[x+1]);
}
}
else if (Top[x+1] >= vh)
{
if (Bot[x+1] < vh)
{
Poly[p++] = xr;
Poly[p++] = IPY(Top[x+1],vh,Bot[x+1]);
}
if (Bot[x+1] < vl)
{
Poly[p++] = xr;
Poly[p++] = IPY(Top[x+1],vl,Bot[x+1]);
}
}
else
{
Poly[p++] = xr;
Poly[p++] = yt;
if (Bot[x+1] < vl)
{
Poly[p++] = xr;
Poly[p++] = IPY(Top[x+1],vl,Bot[x+1]);
}
if (Bot[x+1] >= vh)
{
Poly[p++] = xr;
Poly[p++] = IPY(Top[x+1],vh,Bot[x+1]);
}
}
if (Bot[x+1] < vl)
{
if (Bot[x] >= vl)
{
Poly[p++] = IPX(Bot[x],vl,Bot[x+1]);
Poly[p++] = yb;
}
if (Bot[x] >= vh)
{
Poly[p++] = IPX(Bot[x],vh,Bot[x+1]);
Poly[p++] = yb;
}
}
else if (Bot[x+1] >= vh)
{
if (Bot[x] < vh)
{
Poly[p++] = IPX(Bot[x],vh,Bot[x+1]);
Poly[p++] = yb;
}
if (Bot[x] < vl)
{
Poly[p++] = IPX(Bot[x],vl,Bot[x+1]);
Poly[p++] = yb;
}
}
else
{
Poly[p++] = xr;
Poly[p++] = yb;
if (Bot[x] < vl)
{
Poly[p++] = IPX(Bot[x],vl,Bot[x+1]);
Poly[p++] = yb;
}
if (Bot[x] >= vh)
{
Poly[p++] = IPX(Bot[x],vh,Bot[x+1]);
Poly[p++] = yb;
}
}
if (Bot[x] < vl)
{
if (Top[x] >= vl)
{
Poly[p++] = xl;
Poly[p++] = IPY(Top[x],vl,Bot[x]);
}
if (Top[x] >= vh)
{
Poly[p++] = xl;
Poly[p++] = IPY(Top[x],vh,Bot[x]);
}
}
else if (Bot[x] >= vh)
{
if (Top[x] < vh)
{
Poly[p++] = xl;
Poly[p++] = IPY(Top[x],vh,Bot[x]);
}
if (Top[x] < vl)
{
Poly[p++] = xl;
Poly[p++] = IPY(Top[x],vl,Bot[x]);
}
}
else
{
Poly[p++] = xl;
Poly[p++] = yb;
if (Top[x] < vl)
{
Poly[p++] = xl;
Poly[p++] = IPY(Top[x],vl,Bot[x]);
}
if (Top[x] >= vh)
{
Poly[p++] = xl;
Poly[p++] = IPY(Top[x],vh,Bot[x]);
}
}
FillPoly(p>>1,Poly);
x++;
}
}
}
/* ======== */
/* IsoAreas */
/* ======== */
void IsoAreas(double *Field, int DimX, int DimY, struct ColorStrip Strip[])
{
INT i;
INT y;
double *Top;
double *Bot;
i = 0;
while (Strip[i].Name)
{
Top = Field;
Bot = Field + DimX;
XSetForeground(display,gc,Strip[i].pixel);
for (y = 0 ; y < DimY-1 ; y++)
{
IsoArea(y,Strip[i].Lo,Strip[i].Hi,Top,Bot,DimX);
Top += DimX;
Bot += DimX;
}
++i;
}
}
/* ========= */
/* CalcFrame */
/* ========= */
int CalcFrame(int lats)
{
// int i,l,x,y;
// double *Grid;
//
// nlat = lats;
// nlon = lats * 2;
// VGAX = (sfbox_w - 1.0) / nlon;
// VGAY = (sfbox_h - 1.0) / (nlat-1);
//
// if (!Flag) Flag = malloc((nlon+1) * sizeof(int));
// if (!Frame[0].Grid) Frame[0].Grid = malloc(nlon * nlat * nlev * sizeof(double));
// if (!Frame[0].pixmap) Frame[0].pixmap = XCreatePixmap(display,Cow,sfbox_w,sfbox_h,ScreenD);
// pix = Frame[0].pixmap;
// Grid = Frame[0].Grid;
// IsoAreas(Grid,nlon+1,nlat,Frame[0].Strip);
return 0;
}
Pixmap IsoPixmap(double *Grid, int nlon, int nlat, struct ColorStrip Strip[])
{
pix = XCreatePixmap(display,Cow,sfbox_w,sfbox_h,ScreenD);
//XFillRectangle(display,Cow,gc,0,0,Frame[0].w,Frame[0].h);
Flag = realloc(Flag,(nlon+1) * sizeof(int));
IsoAreas(Grid,nlon+1,nlat,Strip);
//XSetForeground(display,gc,Blue.pixel);
//XDrawRectangle(display,Cow,gc,Frame[0].x-1,Frame[0].y-1,Frame[0].w,Frame[0].h);
return pix;
}
int PPPCompiled(void)
{
FILE *fp;
char fn[128];
strcpy(fn,"puma/run/");
strcat(fn,exec_ppp);
if ((fp = fopen(fn,"r")))
{
fclose(fp);
return 1;
}
return 0;
}
void ShowOrography(void)
{
int i,m,n,k,l,x,y,h,w,lon1,lon2,lat1,lat2,tx,ty,dx;
int r,len,width,height,xp,yp;
char Text[80];
double flon,flat;
XSetFont(display, gc, FixFont->fid);
XSetForeground(display,gc,TextC);
XSetBackground(display,gc,WinBG);
if (Model == PLASIM)
{
if (Planet == MARS)
{
XCopyArea(display,OpmMars,Cow,gc,0,0,
Frame[0].w,Frame[0].h,Frame[0].x,Frame[0].y);
}
else if (Planet == EARTH)
{
XCopyArea(display,OpmEarth,Cow,gc,0,0,
Frame[0].w,Frame[0].h,Frame[0].x,Frame[0].y);
}
return;
}
k = 0; // Frame number 0 reserved for topography
if (noro == 0) // No orography
{
XSetForeground(display,gc,Blue.pixel);
XFillRectangle(display,Cow,gc,Frame[k].x-1,Frame[k].y-1,Frame[k].w,Frame[k].h);
XSetForeground(display,gc,WhitePix);
XSetBackground(display,gc,Blue.pixel);
l = strlen("Aqua Planet Setup");
tx = Frame[k].x + (Frame[k].w - l * FixFontWidth) / 2;
ty = Frame[k].y + Frame[k].h / 2 - FixFontHeight;
XDrawImageString(display,Cow,gc,tx,ty,"Aqua Planet Setup",l);
l = strlen("To change mark option 'Orography'");
tx = Frame[k].x + (Frame[k].w - l * FixFontWidth) / 2;
ty += FixFontHeight;
XDrawImageString(display,Cow,gc,tx,ty,"To change mark option 'Orography'",l);
XSetBackground(display,gc,WinBG);
}
else
{
XCopyArea(display,OpmPrep,Cow,gc,0,0,Frame[0].w,Frame[0].h,Frame[0].x,Frame[0].y);
XDrawRectangle(display,Cow,gc,Frame[k].x-1,Frame[k].y-1,Frame[k].w,Frame[k].h);
l = strlen(Frame[k].t[0]);
tx = Frame[k].x + (Frame[k].w - l * FixFontWidth) / 2;
ty = Frame[k].y - FixFont->descent - 2;
XDrawImageString(display,Cow,gc,tx,ty,Frame[k].t[0],l);
}
if (noro && (Button1Down || (Frame[k].ws && Frame[k].hs)))
{
x = Frame[k].x+Frame[k].xs;
y = Frame[k].y+Frame[k].ys;
w = Frame[k].ws;
h = Frame[k].hs;
if (w < 0) {x += w; w = -w;}
if (h < 0) {y += h; h = -h;}
XSetForeground(display,gc,WhitePix);
XDrawArc(display,Cow,gc,x,y,w,h,0,FULLARC);
XSetForeground(display,gc,BlackPix);
XDrawArc(display,Cow,gc,x-1,y-1,w+2,h+2,0,FULLARC);
flon = 360.0 / Frame[k].w;
flat = 180.0 / Frame[k].h;
lon1 = flon * (x - Frame[k].x);
lon2 = lon1 + flon * w;
lat1 = 90.0 - flat * (y - Frame[k].y);
lat2 = lat1 - flat * h;
sprintf(Frame[k].t[1],"Lon: (%3d:%3d) Lat: (%3d:%3d)",lon1,lon2,lat2,lat1);
l = strlen(Frame[k].t[1]);
tx = Frame[k].x;
ty = Frame[k].y + Frame[k].h + FixFont->ascent;
XDrawImageString(display,Cow,gc,tx,ty,Frame[k].t[1],l);
XSetForeground(display,gc,WhitePix);
sprintf(Frame[k].t[1],"Mouse marks area ");
l = strlen(Frame[k].t[1]);
tx = Frame[k].x;
ty = Frame[k].y + Frame[k].h + FixFont->ascent;
XDrawImageString(display,Cow,gc,tx,ty,Frame[k].t[1],l);
}
}
void ShowMars(void)
{
if (Debug) printf("ShowMars\n");
XPutImage(display,Cow,gc,MapLRM.X,0,0,Frame[1].x,Frame[1].y,MapLRM.w,MapLRM.h);
}
void ShowExo(void)
{
XPutImage(display,Cow,gc,MapLRL.X,0,0,Frame[0].x,Frame[0].y,MapLRL.w,MapLRL.h);
XPutImage(display,Cow,gc,MapLRK.X,0,0,Frame[1].x,Frame[1].y,MapLRK.w,MapLRK.h);
}
void ShowEarth(void)
{
if (Debug) printf("ShowEarth\n");
XPutImage(display,Cow,gc,MapLRE.X,0,0,Frame[1].x,Frame[1].y,MapLRE.w,MapLRE.h);
}
void ShowModeSelector(void)
{
int k,dx,r,m,i,n,len,width,height,xp,yp,l,tx,ty;
char Text[80];
if (Debug) printf("ShowModeSelector\n");
k = 1; // Frame number 1 reserved for mode display
pix = Frame[k].pixmap;
strcpy(Frame[1].t[0],"Spherical Harmonics mode selector");
dx = dxsh;
r = (dx+dx) / 3;
XSetForeground(display,gc,BlackPix);
XFillRectangle(display,pix,gc,0,0,Frame[k].w,Frame[k].h);
for (m=0,i=0 ; m <= DimTr ; ++m)
{
for (n=m ; n <= DimTr ; ++n,++i)
{
if (Ampli[i]) XSetForeground(display,gc,Green.pixel);
else XSetForeground(display,gc, Red.pixel);
XFillArc(display,pix,gc,ModeX[i]-dxs2,ModeY[i]-dxs2,r,r,0,360*64);
}
}
/* Draw mode legend */
XSetForeground(display,gc,Yellow.pixel);
XSetBackground(display,gc,BlackPix);
XSetFont(display, gc, ModFont->fid);
for (i=0 ; i < 21 ; i+=2)
{
sprintf(Text,"%d",i);
len = strlen(Text);
width = XTextWidth(ModFont,Text,len);
height = ModFont->ascent + ModFont->descent;
xp = dx + i * dx - width/2 - ModFontWidth/2 + 1;
yp = ModFontHeight;
XDrawImageString(display,pix,gc,xp,yp,Text,len);
}
strcpy(Text,"PUMA T21 only!");
len = strlen(Text);
xp = dx - ModFontWidth/2 + 1;
yp = 2 * ModFontHeight + 10 * dx;
XDrawImageString(display,pix,gc,xp,yp,Text,len);
XSetForeground(display,gc,WhitePix);
strcpy(Text,"MB 1: Toggle mode");
len = strlen(Text);
yp += 2*dx;
XDrawImageString(display,pix,gc,xp,yp,Text,len);
strcpy(Text,"MB 2: Toggle column");
len = strlen(Text);
yp += dx;
XDrawImageString(display,pix,gc,xp,yp,Text,len);
strcpy(Text,"MB 3: Toggle row");
len = strlen(Text);
yp += dx;
XDrawImageString(display,pix,gc,xp,yp,Text,len);
XSetForeground(display,gc,Yellow.pixel);
strcpy(Text,"n : Total Wavenumber");
len = strlen(Text);
xp = dx - ModFontWidth/2 + 1;
yp = 2 * ModFontHeight + 18 * dx;
XDrawImageString(display,pix,gc,xp,yp,Text,len);
XSetForeground(display,gc,LightBlue.pixel);
for (i=0 ; i < 21 ; i+=2)
{
sprintf(Text,"%d",i);
len = strlen(Text);
width = XTextWidth(ModFont,Text,len);
height = ModFont->ascent + ModFont->descent;
xp = Frame[k].w - width - 2;
yp = 2 * ModFontHeight + i * dx;
XDrawImageString(display,pix,gc,xp,yp,Text,len);
}
strcpy(Text,"m : Zonal Wavenumber");
len = strlen(Text);
xp = dx - ModFontWidth/2 + 1;
yp = 2 * ModFontHeight + 19 * dx;
XDrawImageString(display,pix,gc,xp,yp,Text,len);
XSetForeground(display,gc,Green.pixel);
strcpy(Text,"Mode is on");
len = strlen(Text);
xp = dx - ModFontWidth/2 + 1;
yp = ModFontHeight + 16 * dx;
XFillArc(display,pix,gc,xp,yp+ModFont->descent+2,r,r,0,360*64);
xp += dx;
yp += dx;
XDrawImageString(display,pix,gc,xp,yp,Text,len);
XSetForeground(display,gc,Red.pixel);
strcpy(Text,"Mode is off");
len = strlen(Text);
xp = dx - ModFontWidth/2 + 1;
yp = ModFontHeight + 17 * dx;
XFillArc(display,pix,gc,xp,yp+ModFont->descent+2,r,r,0,360*64);
xp += dx;
yp += dx;
XDrawImageString(display,pix,gc,xp,yp,Text,len);
XSetForeground(display,gc,WhitePix);
strcpy(Text,"Switch all modes on");
len = strlen(Text);
xp = dx - ModFontWidth/2 + 1;
yp = ModFontHeight + 20 * dx;
XFillArc(display,pix,gc,xp,yp+ModFont->descent+2,r,r,0,360*64);
xp += dx;
yp += dx;
XSetForeground(display,gc,Green.pixel);
XDrawImageString(display,pix,gc,xp,yp,Text,len);
XSetForeground(display,gc,WhitePix);
strcpy(Text,"Switch all modes off");
len = strlen(Text);
xp = dx - ModFontWidth/2 + 1;
yp = ModFontHeight + 21 * dx;
XFillArc(display,pix,gc,xp,yp+ModFont->descent+2,r,r,0,360*64);
xp += dx;
yp += dx;
XSetForeground(display,gc,Red.pixel);
XDrawImageString(display,pix,gc,xp,yp,Text,len);
XCopyArea(display,Frame[k].pixmap,Cow,gc,0,0,Frame[k].w,Frame[k].h,Frame[k].x,Frame[k].y);
XSetForeground(display,gc,Cyan.pixel);
l = strlen(Frame[k].t[0]);
tx = Frame[k].x + (Frame[k].w - l * FixFontWidth) / 2;
ty = Frame[k].y - FixFont->descent - 2;
XDrawImageString(display,Cow,gc,tx,ty,Frame[k].t[0],l);
XSetForeground(display,gc,LightBlue.pixel);
l = strlen(Frame[k].t[1]);
if (l)
{
tx = Frame[k].x + (3 * ModFontWidth) / 2;
ty = Frame[k].y + Frame[k].h + FixFont->ascent;
XDrawImageString(display,Cow,gc,tx,ty,Frame[k].t[1],l);
}
}
void ShowFrame1(void)
{
if (Model == PLASIM)
{
if (Planet == MARS) ShowMars();
else if (Planet == EXO ) ShowExo();
else ShowEarth();
}
else ShowModeSelector();
}
void PreProcess(void)
{
FinishLine();
if (Model == PUMA)
{
if (CheckPumaNamelist()) return;
GenerateNames();
WritePPPNamelist();
WritePumaNamelist();
if (!PPPCompiled()) BuildPPP();
WriteRunPPP();
Preprocessed = 1;
if (Latitudes < 1000)
sprintf(oro_name,"puma/run/N%3.3d_surf_0129.sra",Latitudes);
else
sprintf(oro_name,"puma/run/N%d_surf_0129.sra",Latitudes);
OroPrep = ReadGrid(oro_name,Latitudes,RevGra);
OpmPrep = IsoPixmap(OroPrep,2*Latitudes,Latitudes,OroStrip);
free(OroPrep);
OroClear = 0;
}
else
{
RedMessage("Preprocessing is for PUMA only");
sleep(5);
}
}
void ClearOro(void)
{
OroClear = 1;
OroAqua = 1;
OroAno = 0;
PreProcess();
}
void WriteNamelistFile(char *nl, int instance)
{
char *shomo = ShortModelName[Model];
struct SelStruct *Sel;
char fn[256];
FILE *fp;
if (Multirun > 1)
sprintf(fn,"%s/run/%s_namelist_%2.2d",shomo,nl,instance);
else
sprintf(fn,"%s/run/%s_namelist",shomo,nl);
fp = fopen(fn,"w");
if (fp == NULL)
{
printf("Could not open file <%s> for writing\n",fn);
return; /* Failure */
}
// Write namelist file
fprintf(fp," &%s_nl\n",nl);
// Write special parameters
if (!strcmp(nl,"icemod"))
{
fprintf(fp," %-12s=%6d\n","NICE",Ice);
}
if (!strcmp(nl,"oceanmod"))
{
fprintf(fp," %-12s=%6d\n","NOCEAN",Oce);
fprintf(fp," %-12s=%6d\n","NLSG" ,Lsg);
}
if (!strcmp(nl,"plasim"))
{
fprintf(fp," %-12s=%6d\n","NOUTPUT",noutput);
fprintf(fp," %-12s=%6d\n","NGUI" ,ngui);
fprintf(fp," %-12s=%6d\n","N_START_YEAR",SimStart);
if (Lsg) fprintf(fp," %-12s=%6d\n","N_DAYS_PER_YEAR",360);
else if (Planet != MARS) fprintf(fp," %-12s=%6d\n","N_DAYS_PER_YEAR",365);
if (ngui) fprintf(fp," %-12s=%6d\n","N_RUN_YEARS",SimYears);
else fprintf(fp," %-12s=%6d\n","N_RUN_YEARS",1);
fprintf(fp," %-12s=%6d\n","N_RUN_MONTHS",0);
fprintf(fp," %-12s=%6d\n","N_RUN_DAYS",0);
}
for (Sel = ComEnd->Next ; Sel ; Sel = Sel->Next)
{
if (Sel->Item && !strcasecmp(Sel->Item->list,nl))
{
if (Sel->type == SEL_TEVA)
fprintf(fp," %-12s=%c%s%c\n",Sel->text,'\"',Sel->teva,'\"');
else
fprintf(fp," %-12s=%s\n",Sel->text,Sel->teva);
}
}
fprintf(fp," /END\n");
fclose(fp);
}
/* =================== */
/* WritePlasimNamelist */
/* =================== */
void WritePlasimNamelist(void)
{
int imr;
FinishLine();
for (imr = 0 ; imr < Multirun ; ++imr)
{
WriteNamelistFile("fluxmod" ,imr);
WriteNamelistFile("icemod" ,imr);
WriteNamelistFile("landmod" ,imr);
WriteNamelistFile("vegmod" ,imr);
WriteNamelistFile("miscmod" ,imr);
WriteNamelistFile("oceanmod",imr);
WriteNamelistFile("planet" ,imr);
WriteNamelistFile("plasim" ,imr);
WriteNamelistFile("radmod" ,imr);
WriteNamelistFile("rainmod" ,imr);
WriteNamelistFile("seamod" ,imr);
WriteNamelistFile("surfmod" ,imr);
}
}
void BuildScripts(void)
{
if (Model == PUMA)
{
if (CheckPumaNamelist()) return;
GenerateNames();
WritePumaNamelist();
if (!Build(PUMA)) Exit();
WriteRunScript(PUMA);
}
if (Model == SAM)
{
if (CheckPumaNamelist()) return;
GenerateNames();
WritePumaNamelist();
if (!Build(SAM)) Exit();
WriteRunScript(SAM);
}
if (Model == CAT)
{
if (CheckCATNamelist()) return;
GenerateNames();
WriteCatNamelist();
if (!Build(CAT)) Exit();
WriteRunScript(CAT);
}
if (Model == PLASIM)
{
CheckPlasimNamelist();
GenerateNames();
WritePlasimNamelist();
if (!Build(PLASIM)) Exit();
WriteRunScript(PLASIM);
}
}
void SaveExit(void)
{
BuildScripts();
if ((noro || Yoden) && !Preprocessed && Model == PUMA) PreProcess();
Exit();
}
void SaveRun(void)
{
char command[256];
BuildScripts();
if ((noro || Yoden) && !Preprocessed && Model == PUMA) PreProcess();
sprintf(command,"%s/run/%s %s/run &",ShortModelName[Model],run_name,ShortModelName[Model]);
system(command);
printf("\n=== Success: Launched process %s ===\n\n",run_name);
Exit();
}
void MarkRectangle(void)
{
if (Model != PUMA) return;
if (WinEvent.type == ButtonPress)
{
Frame[FrameNo].xs = WinEvent.xbutton.x - Frame[FrameNo].x;
Frame[FrameNo].ys = WinEvent.xbutton.y - Frame[FrameNo].y;
Frame[FrameNo].ws = 0;
Frame[FrameNo].hs = 0;
}
if (WinEvent.type == ButtonRelease)
{
Frame[FrameNo].ws = WinEvent.xbutton.x - Frame[FrameNo].x - Frame[FrameNo].xs;
Frame[FrameNo].hs = WinEvent.xbutton.y - Frame[FrameNo].y - Frame[FrameNo].ys;
}
if (WinEvent.type == MotionNotify && Button1Down)
{
Frame[FrameNo].ws = WinEvent.xbutton.x - Frame[FrameNo].x - Frame[FrameNo].xs;
Frame[FrameNo].hs = WinEvent.xbutton.y - Frame[FrameNo].y - Frame[FrameNo].ys;
}
}
/* ==================================================== */
/* AzimuthalImage - Display map in azimuthal projection */
/* ==================================================== */
void AzimuthalImage(struct MapImageStruct *s, struct MapImageStruct *d)
{
int lam; // lambda pixel coordinate in source image
int phi; // phi pixel coordinate in source image
int x ; // x pixel coordinate in destination image
int y ; // y pixel coordinate in destination image
int dxc; // pixel coordinate of centre position
int dxl; // pixel coordinate of left most position
int dxr; // pixel coordinate of right most position
int dx ; // centre relative x position
int dy ; // centre relative y position
int p00; // euqator
int l00; // reference longitude
unsigned int dih; // destination image height
unsigned int diw; // destination image width
unsigned int dpw; // destination image padded width
double rad; // pixel radius of new image
double ysc; // yscale = source height / destination height
double rho; // distance from centre
double xpi; // x scale factor = 2 * PI / width
double ypi; // y scale factor = PI / height
double xrf;
double yrf;
XImage *sX; // source image
XImage *dX; // destination image
// Destroy old image structure inclusive data storage
if (d->X) XDestroyImage(d->X);
// Set width of new image
diw = d->w;
// Pad width of new image to a multiple of 8
dpw = (diw + 7) & 0xFFF8;
// Set height of new image
dih = d->h;
// Allocate space for image data
d->d = calloc(dpw * dih,4);
// Create image structure
dX = d->X = XCreateImage(display,CopyFromParent,ScreenD,ZPixmap,0,d->d,dpw,dih,8,0);
sX = s->X;
p00 = s->h >> 1;
rad = dih >> 1;
dxc = diw >> 1;
dxl = MAX(dxc - rad, 0);
dxr = MIN(dxc + rad, diw);
xpi = s->w / M_PI * 0.5;
ypi = s->h / M_PI;
ysc = (double)s->h / (double)dih;
l00 = (int)((d->l * s->w) / 360 + s->w/2) % s->w;
xrf = (double)diw / pow(2.0,31),
yrf = (double)dih / pow(2.0,31);
// Paint some stars on the sky
srandom(Seed);
for (y = 0 ; y < (diw * dih) >> 8 ; ++y)
XPutPixel(dX,xrf*random(),yrf*random(),WhitePix);
for (y = 0 ; y < dih ; ++y)
{
dy = y - rad;
phi = y * ysc;
for (x = dxl ; x < dxr ; ++x)
{
dx = x - dxc;
rho = sqrt(dx * dx + dy * dy);
if (rho < rad)
{
lam = l00 + xpi * atan2(dx / rad, cos(asin(rho / rad)));
phi = p00 + ypi * asin(dy / rad);
XPutPixel(dX,x,y,XGetPixel(sX,lam,phi));
}
}
}
}
/* =============================================== */
/* RectImage - Display map in azimuthal projection */
/* =============================================== */
void RectImage(struct MapImageStruct *s, struct MapImageStruct *d)
{
int x ; // x pixel coordinate in destination image
int y ; // y pixel coordinate in destination image
unsigned int dih; // destination image height
unsigned int diw; // destination image width
unsigned int dpw; // destination image padded width
XImage *sX; // source image
XImage *dX; // destination image
// Destroy old image structure inclusive data storage
if (d->X) XDestroyImage(d->X);
// Set width of new image
diw = d->w;
// Pad width of new image to a multiple of 8
dpw = (diw + 7) & 0xFFF8;
// Set height of new image
dih = d->h;
// Allocate space for image data
d->d = calloc(dpw * dih,4);
// Create image structure
dX = d->X = XCreateImage(display,CopyFromParent,ScreenD,ZPixmap,0,d->d,dpw,dih,8,0);
sX = s->X;
for (y = 0 ; y < dih ; ++y)
{
for (x = 0 ; x < diw ; ++x)
{
XPutPixel(dX,x,y,XGetPixel(sX,x,y));
}
}
}
void ToggleMode(void)
{
int i,j,m,n,mx,my,dx,dy;
if (Model == PLASIM) // Rotate image
{
if (WinEvent.xbutton.button == Button1) // Rotate right
{
if (Planet == MARS)
{
MapLRM.l += 10;
if (MapLRM.l > 180) MapLRM.l -= 360;
AzimuthalImage(&MapHRM,&MapLRM);
}
else
{
MapLRE.l += 10;
if (MapLRE.l > 180) MapLRE.l -= 360;
AzimuthalImage(&MapHRE,&MapLRE);
}
}
else if (WinEvent.xbutton.button == Button3) // Rotate left
{
if (Planet == MARS)
{
MapLRM.l -= 10;
if (MapLRM.l < -180) MapLRM.l += 360;
AzimuthalImage(&MapHRM,&MapLRM);
}
else
{
MapLRE.l -= 10;
if (MapLRE.l < -180) MapLRE.l += 360;
AzimuthalImage(&MapHRE,&MapLRE);
}
}
return;
}
if (WinEvent.type == ButtonPress)
{
mx = WinEvent.xbutton.x - Frame[FrameNo].x;
my = WinEvent.xbutton.y - Frame[FrameNo].y;
for (i=0 ; i < DimSE ; ++i)
{
dx = mx - ModeX[i];
dy = my - ModeY[i];
if ((dx*dx + dy*dy) < ModeRadiusSq) break;
}
if (WinEvent.xbutton.button == Button1)
{
if (i == DimSH ) // All modes on
for (j=0 ; j < DimSH ; ++j) Ampli[j] = 1;
else if (i == DimSH+1) // All modes off
for (j=0 ; j < DimSH ; ++j) Ampli[j] = 0;
else Ampli[i] = 1 - Ampli[i];
}
else if (WinEvent.xbutton.button == Button2 && i < DimSH)
{
n = ModeN[i];
for (j=0 ; j < DimSH ; ++j)
if (ModeN[j] == n) Ampli[j] = 1 - Ampli[j];
}
else if (WinEvent.xbutton.button == Button3 && i < DimSH)
{
m = ModeM[i];
for (j=0 ; j < DimSH ; ++j)
if (ModeM[j] == m) Ampli[j] = 1 - Ampli[j];
}
}
if (WinEvent.type == MotionNotify)
{
mx = WinEvent.xbutton.x - Frame[FrameNo].x;
my = WinEvent.xbutton.y - Frame[FrameNo].y;
for (i=0 ; i < DimSH ; ++i)
{
dx = mx - ModeX[i];
dy = my - ModeY[i];
if ((dx*dx + dy*dy) < ModeRadiusSq)
{
sprintf(Frame[1].t[1],"Mode (%2d:%2d)",ModeN[i],ModeM[i]);
return;
}
}
Frame[1].t[1][0] = 0;
}
return;
}
void InitFrames(void)
{
int i,j,n;
int moselw;
FILE *ftp;
/* Size and position of orography window */
sfbox_w = 360;
sfbox_h = 180;
sfbox_x = WINDOW_WIDTH - sfbox_w - 3 * FixFontWidth;
sfbox_y = nlbox_y + 4;
/* Parameter for default orographies */
nlat = 64;
nlon = nlat * 2;
VGAX = (sfbox_w - 1.0) / nlon;
VGAY = (sfbox_h - 1.0) / (nlat-1);
/* Read T42 orography for Earth and Mars */
OroEarth = ReadGrid("plasim/dat/T42/N064_surf_0129.sra",nlat,RevGra);
OroMars = ReadGrid("plasim/dat/T42_mars/N064_surf_0129.sra",nlat,1.0/3.74);
OpmEarth = IsoPixmap(OroEarth,nlon,nlat,OroStrip);
OpmPrep = IsoPixmap(OroEarth,nlon,nlat,OroStrip);
OpmMars = IsoPixmap(OroMars ,nlon,nlat,OroMarsStrip);
free(OroEarth);
free(OroMars);
/* Check for orography in run directory */
ftp = fopen(oro_name,"r");
if (ftp) fclose(ftp);
else strcpy(oro_name,"puma/dat/N064_surf_0129.sra");
// Orography
n = 0;
Frame[n].x = sfbox_x;
Frame[n].y = sfbox_y + FixFontHeight;
Frame[n].w = sfbox_w;
Frame[n].h = sfbox_h;
Frame[n].b = DarkGreen.pixel;
Frame[n].f = WhitePix;
strcpy(Frame[n].t[0],"Orography");
strcpy(Frame[n].t[1],"64 x 32");
strcpy(Frame[n].t[2],"");
Frame[n].Action = MarkRectangle;
Frame[n].xs = 110;
Frame[n].ys = 95;
Frame[n].ws = 60;
Frame[n].hs = 40;
SelAno->x = Frame[n].x;
SelAno->y = Frame[n].y + Frame[n].h + FixFontHeight;
SelAno->edco = 6;
SelAno->w = SelAno->edco * FixFontWidth + 2;
SelAno->xt = SelAno->x + (SelAno->edco + 1) * FixFontWidth;
SelAno->yt = SelAno->y + FixFont->ascent + 1;
strcpy(SelAno->teva," 0");
Button[4].y = SelAno->y - FixFontHeight/2; // Clear orography button
Button[4].x = Frame[n].x + Frame[n].w - 6 * FixFontWidth;
// T21 mode selector
++n;
Frame[n].x = sfbox_x;
Frame[n].y = Frame[n-1].y + Frame[n-1].h + 4 * FixFontHeight;
moselw = sfbox_w;
if (SmallScreen)
{
moselw = WinYSize - Frame[n].y - FixFontHeight - FixFontHeight/2;
Frame[n].x += (sfbox_x - moselw) / 2;
}
Frame[n].w = moselw;
Frame[n].h = moselw;
Frame[n].b = BlackPix;
Frame[n].f = WhitePix;
strcpy(Frame[n].t[0],"Spherical Harmonics mode selector");
strcpy(Frame[n].t[1],"");
strcpy(Frame[n].t[2],"");
Frame[n].Action = ToggleMode;
sfbox_b = Frame[n].y + Frame[n].h - Frame[0].y + 2 * FixFontHeight + FixFontHeight/2;
Frames = n + 1;
}
void InitButtons(void)
{
int n;
bubox_w = 64;
bubox_h = 64;
bubox_x = WINDOW_WIDTH - 4 * 64 - 6 * FixFontWidth;
bubox_y = 8;
// Preprocess
n = 0;
Button[n].x = bubox_x;
Button[n].y = bubox_y;
Button[n].w = bubox_w;
Button[n].h = bubox_h;
Button[n].b = Yellow.pixel;
Button[n].f = BlackPix;
strcpy(Button[n].t[0],"Pre-");
strcpy(Button[n].t[1],"pro-");
strcpy(Button[n].t[2],"cess");
Button[n].Action = PreProcess;
// Save & Exit
++n;
Button[n].x = Button[n-1].x + Button[n-1].w + FixFontWidth;
Button[n].y = Button[n-1].y;
Button[n].w = bubox_w;
Button[n].h = bubox_h;
Button[n].b = DarkGreen.pixel;
Button[n].f = WhitePix;
strcpy(Button[n].t[0],"Save");
strcpy(Button[n].t[1],"&");
strcpy(Button[n].t[2],"Exit");
Button[n].Action = SaveExit;
// Save & Run
++n;
Button[n].x = Button[n-1].x + Button[n-1].w + FixFontWidth;
Button[n].y = Button[n-1].y;
Button[n].w = bubox_w;
Button[n].h = bubox_h;
Button[n].b = DarkBlue.pixel;
Button[n].f = WhitePix;
strcpy(Button[n].t[0],"Save");
strcpy(Button[n].t[1],"&");
strcpy(Button[n].t[2],"Run");
Button[n].Action = SaveRun;
// Abort
++n;
Button[n].x = Button[n-1].x + Button[n-1].w + FixFontWidth;
Button[n].y = Button[n-1].y;
Button[n].w = bubox_w;
Button[n].h = bubox_h;
Button[n].b = Red.pixel;
Button[n].f = WhitePix;
strcpy(Button[n].t[1],"Abort");
Button[n].Action = Abort;
// Clear orography
++n;
// Button[n].x = Button[n-1].x;
// Button[n].y = Button[n-1].y; // set in InitFrames
Button[n].w = 6 * FixFontWidth;
Button[n].h = 2 * FixFontHeight;
Button[n].b = DarkBlue.pixel;
Button[n].f = Yellow.pixel;
strcpy(Button[n].t[1],"Clear");
Button[n].Action = ClearOro;
}
/* ================== */
/* CreateModeSelector */
/* ================== */
void CreateModeSelector(int k)
{
int i,j,m,n;
int x,y,len,width,height;
int r,dx,dy,xp,yp;
char Text[20];
pix = Frame[k].pixmap = XCreatePixmap(display,Cow,Frame[k].w,Frame[k].h,ScreenD);
if (!Ampli) Ampli = malloc(DimSE * sizeof(int));
if (!ModeX) ModeX = malloc(DimSE * sizeof(int));
if (!ModeY) ModeY = malloc(DimSE * sizeof(int));
if (!ModeM) ModeM = malloc(DimSE * sizeof(int));
if (!ModeN) ModeN = malloc(DimSE * sizeof(int));
dxsh = Frame[k].w / (DimTr + 3);
dxs2 = dxsh / 2;
dx = dxsh;
r = (dx+dx) / 3;
ModeRadiusSq = r*r;
for (m=0,i=0 ; m <= DimTr ; ++m)
{
y = ModFontHeight + 4 + m * dx;
for (n=m ; n <= DimTr ; ++n,++i)
{
x = dx/2 + n * dx;
Ampli[i] = 1;
ModeX[i] = x + dx/2;
ModeY[i] = y + dx/2;
ModeM[i] = m;
ModeN[i] = n;
}
}
i = DimSH; // Button for all modes on
x = dx - ModFontWidth/2 + 1;
y = ModFontHeight + ModFont->descent + 2 + 20 * dx;
Ampli[i] = 0;
ModeX[i] = x + dx/2;
ModeY[i] = y + dx/2;
i++; // Button for all modes off
y += dx;
Ampli[i] = 0;
ModeX[i] = x + dx/2;
ModeY[i] = y + dx/2;
/* Draw mode legend */
dx = dxsh;
XSetForeground(display,gc,Red.pixel);
XSetBackground(display,gc,BlackPix);
for (i=0 ; i < 21 ; i+=2)
{
sprintf(Text,"%d",i);
len = strlen(Text);
width = XTextWidth(ModFont,Text,len);
height = ModFont->ascent + ModFont->descent;
xp = dx + i * dx - width/2 - ModFontWidth/2 + 1;
yp = ModFontHeight;
XDrawImageString(display,pix,gc,xp,yp,Text,len);
}
XSetForeground(display,gc,Blue.pixel);
for (i=0 ; i < 21 ; i+=2)
{
sprintf(Text,"%d",i);
len = strlen(Text);
width = XTextWidth(ModFont,Text,len);
height = ModFont->ascent + ModFont->descent;
xp = Frame[k].x + Frame[k].w - width - 2;
yp = 2 * ModFontHeight + i * dx;
XDrawImageString(display,pix,gc,xp,yp,Text,len);
}
}
void ShowButtons(void)
{
int i,k,l,x,y,d;
XSetFont(display, gc, FixFont->fid);
for (k=0 ; k < DIMBUTTON ; ++k)
{
if (k == 4 && SelAno->hide) continue;
d = Button[k].h / 4;
XSetForeground(display,gc,Button[k].b);
XFillRectangle(display,Cow,gc,Button[k].x,Button[k].y,Button[k].w,Button[k].h);
XSetForeground(display,gc,Button[k].f);
XSetBackground(display,gc,Button[k].b);
for (i=0 ; i < 3 ; ++i)
if (Button[k].t[i][0])
{
l = strlen(Button[k].t[i]);
x = Button[k].x + (Button[k].w - l * FixFontWidth) / 2;
y = Button[k].y + i * d + FixFont->ascent + d/2;
XDrawImageString(display,Cow,gc,x,y,Button[k].t[i],l);
}
}
}
int AllocateColorCells(struct ColorStrip cs[])
{
int i = 0;
XColor xcolor1,xcolor2;
while (cs[i].Name)
{
XAllocNamedColor(display,colormap,cs[i].Name,&xcolor1,&xcolor2);
cs[i].pixel = xcolor1.pixel;
++i;
}
return i;
}
void InitColors(void)
{
/*
Visual *visual;
int count,st;
XStandardColormap *best_map_info;
XStandardColormap bmi[8];
visual = DefaultVisual(display,0);
memset(bmi,0,8*sizeof(XStandardColormap));
best_map_info = bmi;
count = 0;
st = XGetRGBColormaps(display,RootWindow(display,0),&best_map_info,&count,XA_RGB_DEFAULT_MAP);
{
printf("status = %d count=%d\n",st,count);
printf("colormap = %p\n",bmi[0].colormap);
printf("mapping = %x/%x/%x\n",bmi[0].red_max,bmi[0].green_max,bmi[0].blue_max);
}
*/
// colormap = best_map_info->colormap;
AllocateColorCells(OroStrip);
AllocateColorCells(OroMarsStrip);
AllocateColorCells(GibbStrip);
AllocateColorCells(TStrip);
XAllocNamedColor(display,colormap,"red" ,&Red ,&Dummy);
XAllocNamedColor(display,colormap,"green" ,&Green ,&Dummy);
XAllocNamedColor(display,colormap,"blue" ,&Blue ,&Dummy);
XAllocNamedColor(display,colormap,"grey" ,&Grey ,&Dummy);
XAllocNamedColor(display,colormap,"hot pink" ,&LightRed ,&Dummy);
XAllocNamedColor(display,colormap,"dark red" ,&DarkRed ,&Dummy);
XAllocNamedColor(display,colormap,"light blue" ,&LightBlue ,&Dummy);
XAllocNamedColor(display,colormap,"dark blue" ,&DarkBlue ,&Dummy);
XAllocNamedColor(display,colormap,"light green",&LightGreen,&Dummy);
XAllocNamedColor(display,colormap,"dark green" ,&DarkGreen ,&Dummy);
XAllocNamedColor(display,colormap,"yellow" ,&Yellow ,&Dummy);
XAllocNamedColor(display,colormap,"cyan" ,&Cyan ,&Dummy);
TextC = Yellow.pixel;
HeadC = Cyan.pixel;
}
struct BMIstruct
{
int Size;
int Width;
int Height;
short Planes;
short Count;
int Compression;
int SizeImage;
int XPelsPerMeter;
int YPelsPerMeter;
int ClrUsed;
int ClrImportant;
};
// Convert an RGB value to an X11 Pixel
unsigned long create_pixel(long red, long green, long blue)
{
if (ScreenD == 24) // 24 bit true color
{
return blue | green << 8 | red << 16;
}
else if (ScreenD == 16) // 16 bit RGB 565
{
return blue >> 3 | (green >> 2) << 5 | (red >> 3) << 11;
}
else return 0;
}
void SwapIEEE16(char W[2])
{
char B;
B = W[0]; W[0] = W[1]; W[1] = B;
}
void SwapIEEE32(char W[4])
{
char B;
B = W[0]; W[0] = W[3]; W[3] = B;
B = W[1]; W[1] = W[2]; W[2] = B;
}
int ReadINT(FILE *fpi)
{
int k;
fread(&k,sizeof(k),1,fpi);
if (BigEndian) SwapIEEE32((char *)&k);
return k;
}
short ReadSHORT(FILE *fpi)
{
short k;
fread(&k,sizeof(k),1,fpi);
if (BigEndian) SwapIEEE16((char *)&k);
return k;
}
struct BMIstruct ImageBMI;
void ReadImage(struct MapImageStruct *ei, char *filename)
{
char ch;
int i,n,x,y,z;
long r,g,b;
int FileSize;
int Reserved;
int OffBits;
int PicBytes;
int ImgBytes;
int PadWidth;
int PadBytes;
int bpp;
int byr;
FILE *fp;
unsigned char *BuffImageData;
if (!(fp = fopen(filename,"r"))) return;
ch = fgetc(fp);
if (ch != 'B') return;
ch = fgetc(fp);
if (ch != 'M') return;
FileSize = ReadINT(fp);
Reserved = ReadINT(fp);
OffBits = ReadINT(fp);
if (Debug)
{
printf("Properties of %s:\n",filename);
printf("FileSize = %d\n",FileSize);
printf("FileOffset = %d\n",OffBits);
}
ImageBMI.Size = ReadINT(fp);
ImageBMI.Width = ReadINT(fp);
ImageBMI.Height = ReadINT(fp);
ImageBMI.Planes = ReadSHORT(fp);
ImageBMI.Count = ReadSHORT(fp);
ImageBMI.Compression = ReadINT(fp);
ImageBMI.SizeImage = ReadINT(fp);
ImageBMI.XPelsPerMeter = ReadINT(fp);
ImageBMI.YPelsPerMeter = ReadINT(fp);
ImageBMI.ClrUsed = ReadINT(fp);
ImageBMI.ClrImportant = ReadINT(fp);
PadWidth = (ImageBMI.Width + 7) & 0xFFF8;
bpp = ImageBMI.Count >> 3;
PadBytes = (4 - ((ImageBMI.Width * bpp) % 4)) % 4 ;
if (Debug)
{
printf("BMI Size = %d\n",ImageBMI.Size);
printf("BMI Width = %d\n",ImageBMI.Width);
printf("BMI Height = %d\n",ImageBMI.Height);
printf("BMI Planes = %d\n",ImageBMI.Planes);
printf("BMI Count = %d\n",ImageBMI.Count);
printf("BMI ClrUsed = %d\n",ImageBMI.ClrUsed);
printf("BMI ClrImpo = %d\n",ImageBMI.ClrImportant);
printf("Pad Bytes = %d\n",PadBytes);
printf("Pad Width = %d\n",PadWidth);
}
PicBytes = (bpp * ImageBMI.Width + PadBytes) * ImageBMI.Height;
ImgBytes = 4 * PadWidth * ImageBMI.Height;
ei->d = calloc(ImgBytes,1);
BuffImageData = malloc(PicBytes);
fseek(fp,OffBits,SEEK_SET);
n = fread(BuffImageData,1,PicBytes,fp);
fclose(fp);
if (Debug)
{
printf("Size Bytes = %d\n",PicBytes);
printf("Read Bytes = %d\n",n);
}
ei->X = XCreateImage(display,CopyFromParent,ScreenD,ZPixmap,0,
ei->d,PadWidth,ImageBMI.Height,8,0);
for (y = 0 ; y < ImageBMI.Height ; ++y)
{
for (x = 0 ; x < ImageBMI.Width ; ++x)
{
i = bpp * x + (ImageBMI.Height - 1 - y) * (ImageBMI.Width*bpp+PadBytes);
b = BuffImageData[i ];
g = BuffImageData[i+1];
r = BuffImageData[i+2];
XPutPixel(ei->X, x, y, create_pixel(r,g,b));
}
}
free(BuffImageData);
ei->w = ImageBMI.Width;
ei->h = ImageBMI.Height;
}
void ReadLogo(int logo, char *filename)
{
struct MapImageStruct MapI;
ReadImage(&MapI,filename);
Logo[logo].w = MapI.w;
Logo[logo].h = MapI.h;
Logo[logo].X = MapI.X;
if (logo)
{
Logo[logo].x = Logo[logo-1].x + Logo[logo-1].w;
Logo[logo].y = Logo[logo-1].y;
}
}
void ShowCopyright(void)
{
int x,y;
x = CowSizeHints.min_width - 18.5 * ModFontWidth;
y = CowSizeHints.min_height - ModFontHeight/2;
XSetFont(display, gc, ModFont->fid);
XSetForeground(display,gc,Grey.pixel);
XSetBackground(display,gc,BlackPix);
XDrawImageString(display,Cow,gc,x,y,"Image Credit: NASA",18);
}
int redaco;
int RedrawControlWindow(void)
{
int i,l,x,y;
double xrf,yrf;
struct SelStruct *Sel;
XWindowAttributes CurAtt;
if (Debug) printf("Redraw %d\n",redaco++);
XGetWindowAttributes(display,Cow,&CurAtt);
WinXSize = CurAtt.width;
WinYSize = CurAtt.height;
XSetWindowBackground(display,Cow,WinBG);
XClearWindow(display,Cow);
// Paint some stars on the sky
xrf = (double)WinXSize / pow(2.0,31),
yrf = (double)WinYSize / pow(2.0,31);
XSetForeground(display,gc,WhitePix);
srandom(Seed);
for (y = 0 ; y < ((WinXSize * WinYSize) >> 8) ; ++y)
XDrawPoint(display,Cow,gc,xrf*random(),yrf*random());
XSetForeground(display,gc,BlackPix);
XSetBackground(display,gc,WhitePix);
for (Sel = &SelStart ; Sel ; Sel = Sel->Next) ShowSelection(Sel);
if (CursorSel) CursorOn();
ShowOrography();
ShowFrame1();
ShowButtons();
for (l=0 ; l < Logos ; ++l)
{
XPutImage(display,Cow,gc,Logo[l].X,0,0,Logo[l].x,Logo[l].y,Logo[l].w,Logo[l].h);
}
if (Model == PLASIM) ShowCopyright();
XSync(display,0);
return 0;
}
void ChangeResolution(int NewRes)
{
int i;
struct SelStruct *Sel;
for (i=RES_T21 , Sel = SelRes ; i <= RES_T42; ++i , Sel = Sel->Next)
{
if (i == NewRes) Sel->iv = 1;
else Sel->iv = 0;
}
Resolution = NewRes;
}
void UpdateResolution(void)
{
int i;
struct SelStruct *Sel;
if (SelRes)
for (i=RES_T21 , Sel = SelRes ; i <= RES_T42; ++i , Sel = Sel->Next)
{
if (Sel && Sel->iv == 1) Resolution = i;
}
}
char *vcn[6] =
{
"StaticGray",
"GrayScale",
"StaticColor",
"PseudoColor",
"TrueColor",
"DirectColor"
};
void InitGUI(void)
{
int argc = 1;
int i,j,k;
char *WinconTitle1 = {"MoSt - Model Suite (17) - University of Hamburg"};
unsigned long valuemask = 0; /* ignore XGCvalues and use defaults */
FILE *ftp;
FILE *xpp;
XVisualInfo vinfo;
XGCValues values;
XEvent Event;
XWindowAttributes CurAtt;
if ((display=XOpenDisplay(display_name)) == NULL)
{
fprintf(stderr,"%s: cannot connect to X server %s\n",
progname, XDisplayName(display_name));
exit(1);
}
ScreenN = DefaultScreen(display);
ScreenD = XDefaultDepth(display,ScreenN);
ScreenW = DisplayWidth (display,ScreenN);
ScreenH = DisplayHeight(display,ScreenN);
if (ScreenHeight) ScreenH = ScreenHeight;
if (Debug)
{
i=5;
while (!XMatchVisualInfo(display,ScreenN,ScreenD,i--,&vinfo));
printf("Found visual %s at depth %d\n",vcn[++i],ScreenD);
printf("Red mask = %8lx\n",vinfo.red_mask);
printf("Green mask = %8lx\n",vinfo.green_mask);
printf("Blue mask = %8lx\n",vinfo.blue_mask);
}
BlackPix = BlackPixel(display,ScreenN);
WhitePix = WhitePixel(display,ScreenN);
SmallScreen = ScreenH < 768;
wm_hints.initial_state = NormalState;
wm_hints.input = True;
wm_hints.flags = StateHint | InputHint;
class_hints.res_name = progname;
class_hints.res_class = "MOST";
Delwin = XInternAtom(display,"WM_DELETE_WINDOW",0);
LoadFonts();
/* Setup control window */
CowSizeHints.flags = PPosition | PSize | PMinSize | PMaxSize;
CowSizeHints.min_width = MIN(WINDOW_WIDTH,ScreenW);
CowSizeHints.min_height = MIN(740,ScreenH);
CowSizeHints.max_width = CowSizeHints.min_width;
CowSizeHints.max_height = CowSizeHints.min_height;
Cow = XCreateSimpleWindow(display,RootWindow(display,ScreenN),
0,0,
CowSizeHints.max_width,CowSizeHints.max_height,
4,BlackPix,WhitePix);
XStringListToTextProperty(&WinconTitle1,1,&WinconName1);
XSetWMProtocols(display,Cow,&Delwin,1);
XSetWMProperties(display,Cow,&WinconName1,NULL,
NULL,0,&CowSizeHints,&wm_hints,&class_hints);
XSelectInput(display,Cow,ButtonPressMask | ButtonReleaseMask |
PointerMotionMask | KeyPressMask | ExposureMask);
XMapWindow(display,Cow);
XGetWindowAttributes(display,Cow,&CurAtt);
WinXSize = CurAtt.width;
WinYSize = CurAtt.height;
/* Prepare GC */
gc = XCreateGC(display, Cow, valuemask, &values);
XSetFont(display, gc, FixFont->fid);
colormap = XDefaultColormap(display,ScreenN);
XSetForeground(display,gc,BlackPix);
XSetBackground(display,gc,WhitePix);
Mok = XGetModifierMapping(display);
InitColors();
/* Look for Num_Lock key */
for (j=0 ; j < 8 ; ++j)
{
k = Mok->modifiermap[j * Mok->max_keypermod];
if (XkbKeycodeToKeysym(display,k,0,0) == XK_Num_Lock ) NumLockMask = 1 << j;
if (XkbKeycodeToKeysym(display,k,0,0) == XK_Mode_switch) ModeSwitchMask = 1 << j;
}
if (Debug) printf("NumLockMask = %02X\n",NumLockMask );
if (Debug) printf("ModeSwitchMask = %02X\n",ModeSwitchMask);
if (Debug)
for (j=0 ; j < 8 ; ++j)
{
printf("Mok [%d] %d:",Mok->max_keypermod,j);
for (i=0 ; i < Mok->max_keypermod ; ++i)
{
k = Mok->modifiermap[i+j*Mok->max_keypermod];
if (XkbKeycodeToKeysym(display,k,0,0) != NoSymbol)
printf(" %4x %-16.16s ",k,XKeysymToString(XkbKeycodeToKeysym(display,k,0,0)));
}
printf("\n");
}
XDisplayKeycodes(display,&EdiFirstKey,&EdiLastKey);
EdiKeymap = XGetKeyboardMapping(display,EdiFirstKey,EdiLastKey-EdiFirstKey+1,&EdiSymsPerKey);
/* Sun keymaps don't have lower case entries */
for (j=EdiFirstKey ; j <= EdiLastKey ; ++j)
{
k = (j - EdiFirstKey) * EdiSymsPerKey;
if (EdiKeymap[k] >= 'A' && EdiKeymap[k] < 0xE0 && EdiKeymap[k+1] == 0)
{
EdiKeymap[k+1] = EdiKeymap[k];
EdiKeymap[k] += 0x20;
}
}
xpp = fopen("Beginner","r"); // Expert mode ?
if (xpp)
{
Expert = 0;
fclose(xpp);
}
xpp = fopen("cat","r"); // Cat enabled
if (xpp)
{
CatEnabled = 1;
fclose(xpp);
}
xpp = fopen("sam","r"); // Sam enabled
if (xpp)
{
SamEnabled = 1;
fclose(xpp);
}
xpp = fopen("lsg/src/lsgmod.f90","r"); // LSG there ?
if (xpp)
{
LsgEnabled = 1;
fclose(xpp);
}
xpp = fopen("puma/src/mpimod_multi.f90","r"); // Multirun module there ?
if (xpp)
{
MultirunEnabled = 1;
fclose(xpp);
}
// Read name of MPI execute command
xpp = fopen("most_compiler_mpi","r"); // MPI installed ?
if (xpp)
{
fgets(Buffer,LINEMAX,xpp);
if (Buffer[strlen(Buffer)-1] == 10) Buffer[strlen(Buffer)-1] = 0;
if (Buffer[strlen(Buffer)-1] == 13) Buffer[strlen(Buffer)-1] = 0;
if (!strncmp(Buffer,"MPI_RUN=",8)) strcpy(mpirun,Buffer+8);
fclose(xpp);
}
InitLogo();
ReadLogo(0,"images/KC-Logo_RGB.bmp");
ReadLogo(1,"images/puma.bmp");
ReadLogo(2,"images/cat.bmp");
ReadLogo(3,"images/plasim.bmp");
ReadImage(&MapHRE,"images/earth.bmp");
ReadImage(&MapHRM,"images/mars.bmp");
ReadImage(&MapLRK,"images/Kepler-16.bmp");
ReadImage(&MapLRL,"images/habit360x180.bmp");
opbox_y = 8 + 64 + 2 * FixFontHeight;
InitSelections();
InitNamelist();
ChangeModel(PLASIM);
NamelistSelector(PLASIM);
ChangeModel(CAT);
NamelistSelector(CAT);
ChangeModel(SAM);
NamelistSelector(SAM);
ChangeModel(PUMA);
NamelistSelector(PUMA);
if (ReadSettings(cfg_file))
{
UpdateResolution();
UpdateSelections(&SelStart);
}
InitFrames();
CalcFrame(nlat);
CreateModeSelector(1);
InitButtons();
MapLRE.w = Frame[1].w;
MapLRE.h = Frame[1].h;
MapLRK.w = Frame[1].w;
MapLRK.h = Frame[1].h;
MapLRM.w = Frame[1].w;
MapLRM.h = Frame[1].h;
MapLRL.w = Frame[0].w;
MapLRL.h = Frame[0].h;
MapLRM.l = -90;
AzimuthalImage(&MapHRE,&MapLRE);
AzimuthalImage(&MapHRM,&MapLRM);
RedrawControlWindow();
}
int HitBox(struct SelStruct *Sel)
{
return (
(WinEvent.xbutton.button == Button1) &&
(WinEvent.xbutton.x >= Sel->x) &&
(WinEvent.xbutton.x < Sel->x + Sel->w) &&
(WinEvent.xbutton.y >= Sel->y) &&
(WinEvent.xbutton.y < Sel->y + Sel->h));
}
int HitButton(int k)
{
return (
(WinEvent.xbutton.button == Button1) &&
(WinEvent.xbutton.x >= Button[k].x) &&
(WinEvent.xbutton.x < Button[k].x + Button[k].w) &&
(WinEvent.xbutton.y >= Button[k].y) &&
(WinEvent.xbutton.y < Button[k].y + Button[k].h));
}
int HitFrame(int k)
{
return (
(WinEvent.xbutton.x >= Frame[k].x) &&
(WinEvent.xbutton.x < Frame[k].x + Frame[k].w) &&
(WinEvent.xbutton.y >= Frame[k].y) &&
(WinEvent.xbutton.y < Frame[k].y + Frame[k].h));
}
int OnFrame(int i)
{
if (HitFrame(i))
{
FrameNo = i;
Frame[i].Action();
return 1;
}
return 0;
}
void OnMouseClick(void)
{
int i,j,cp;
struct SelStruct *Sel;
/* Check Action Buttons */
for (i=0 ; i < DIMBUTTON ; ++i)
{
if (HitButton(i))
{
Button[i].Action();
return;
}
}
/* Check for model switch */
for (i = PUMA , Sel = SelMod ; i < MODELS ; ++i , Sel = Sel->Next)
{
if (HitBox(Sel) && Model != i)
{
if (i == CAT && !CatEnabled) return; // Hide CAT
if (Debug) printf("Change model from %d to %d\n",Model,i);
ChangeModel(i);
CalcFrame(Latitudes);
return;
}
}
/* Continue with all other boxes */
for ( ; Sel ; Sel = Sel->Next)
{
if (Sel->type == SEL_CHECK && HitBox(Sel) && !Sel->no)
{
cp = -1;
for (i=0 ; i < PLANETS ; ++i) if (Sel == SelPlanet[i]) cp = i;
if (cp >= 0 && Planet != cp) ChangePlanet(cp);
else
{
Sel->iv = !Sel->iv;
if (Sel->piv) *Sel->piv = Sel->iv;
}
}
else if ((Sel->type == SEL_INT || Sel->type == SEL_REAL) && HitBox(Sel))
{
// printf("Target is <%s>\n",Sel->text);
if (Sel != CursorSel) FinishLine();
CursorSel = Sel;
CursorCol = (WinEvent.xbutton.x - Sel->x) / FixFontWidth;
if (CursorCol > Sel->edco-1) CursorCol = Sel->edco-1;
CursorOn();
}
}
/* Allow only one horizontal resolution */
if (SelRes)
{
for (i = RES_T21 , Sel = SelRes ; i <= RES_T42 ; ++i , Sel = Sel->Next)
if (HitBox(Sel))
{
ChangeResolution(i);
return;
}
}
}
int EdiDecodeKey(void)
{
int ShiftStatus;
int ShiftIndex;
int KeyCode;
int KeyIndex;
ShiftStatus = WinEvent.xkey.state;
KeyIndex = (WinEvent.xkey.keycode-EdiFirstKey) * EdiSymsPerKey;
KeyCode = EdiKeymap[KeyIndex]; // Code with no modifiers
if (ShiftStatus & 0x04) // Control
{
if (KeyCode >= 0x40 && KeyCode < 0x80) KeyCode &= 0x1F;
}
else if (ShiftStatus & NumLockMask &&
EdiKeymap[KeyIndex+1] >= XK_KP_Separator && // Numlock
EdiKeymap[KeyIndex+1] <= XK_KP_9) // PC Keypad
KeyCode = EdiKeymap[KeyIndex+1] - XK_KP_Space;
else if (ShiftStatus & NumLockMask &&
EdiKeymap[KeyIndex+2] >= XK_KP_Separator && // Numlock
EdiKeymap[KeyIndex+2] <= XK_KP_9) // SUN Keypad
KeyCode = EdiKeymap[KeyIndex+2] - XK_KP_Space;
else
{
if (ShiftStatus & ModeSwitchMask) ShiftIndex = 2; // Alt Gr
else ShiftIndex = ShiftStatus & 1; // Normal & Shift
if (ShiftIndex == 1 && KeyCode >= XK_F1 && KeyCode <= XK_F12) KeyCode += 12;
else KeyCode = EdiKeymap[KeyIndex + ShiftIndex];
}
if (ShiftStatus & 0x02) // Caps Lock
{
if (KeyCode >= 'a' && KeyCode <= 'z' ) KeyCode -= 0x20; // ASCII
if (KeyCode >= 0xE0 && KeyCode <= 0xFD) KeyCode -= 0x20; // Latin-1
}
if (KeyCode == XK_KP_Left ) KeyCode = XK_Left;
if (KeyCode == XK_KP_Right ) KeyCode = XK_Right;
if (KeyCode == XK_KP_Up ) KeyCode = XK_Up;
if (KeyCode == XK_KP_Down ) KeyCode = XK_Down;
if (KeyCode == XK_KP_Home ) KeyCode = XK_Home;
if (KeyCode == XK_KP_End ) KeyCode = XK_End ;
if (KeyCode == XK_KP_Page_Up ) KeyCode = XK_Page_Up;
if (KeyCode == XK_KP_Page_Down ) KeyCode = XK_Page_Down;
if (KeyCode == XK_KP_Enter ) KeyCode = XK_Return;
if (KeyCode == XK_KP_Add ) KeyCode = '+';
if (KeyCode == XK_KP_Subtract ) KeyCode = '-';
if (KeyCode == XK_KP_Multiply ) KeyCode = '*';
if (KeyCode == XK_KP_Divide ) KeyCode = '/';
if (Debug)
{
if (KeyCode >= ' ' && KeyCode <= 255) printf("'%c' ",KeyCode);
else printf("--- ");
printf("Key [%x] State [%2x]\n",WinEvent.xkey.keycode,WinEvent.xkey.state);
for (ShiftIndex = 0 ; ShiftIndex < EdiSymsPerKey ; ++ShiftIndex)
{
if (EdiKeymap[KeyIndex + ShiftIndex] && XKeysymToString(EdiKeymap[KeyIndex + ShiftIndex]))
{
printf(" %d: <%x> '%c' (%s)\n",
ShiftIndex,(unsigned int)EdiKeymap[KeyIndex + ShiftIndex],
(int)EdiKeymap[KeyIndex + ShiftIndex],
XKeysymToString(EdiKeymap[KeyIndex + ShiftIndex]));
}
}
printf("\n");
}
return KeyCode;
}
void EditUpLine(void)
{
FinishLine();
if (CursorSel == NULL || CursorSel->Prev == NULL) return;
if (CursorSel->Prev->type != SEL_INT && CursorSel->Prev->type != SEL_REAL) return;
CursorSel = CursorSel->Prev;
if (CursorCol > CursorSel->edco-1) CursorCol = CursorSel->edco-1;
}
void EditDownLine(void)
{
FinishLine();
if (CursorSel == NULL || CursorSel->Next == NULL) return;
if (CursorSel->Next->type != SEL_INT && CursorSel->Next->type != SEL_REAL) return;
CursorSel = CursorSel->Next;
if (CursorCol > CursorSel->edco-1) CursorCol = CursorSel->edco-1;
}
void EditReturnLine(void)
{
CursorCol = 0;
EditDownLine();
}
void EditLeftChar(void)
{
if (CursorCol > 0) --CursorCol;
}
void EditRightChar(void)
{
if (CursorCol < CursorSel->edco-1) ++CursorCol;
}
void EmitChar(int ch)
{
if (CursorSel)
{
CursorSel->teva[CursorCol] = ch;
EditRightChar();
}
} /* EmitChar */
void DeleteRightChar(void)
{
int i;
for (i=CursorCol ; i < CursorSel->edco-1 ; ++i)
CursorSel->teva[i] = CursorSel->teva[i+1];
CursorSel->teva[CursorSel->edco-1] = ' ';
}
void DeleteLeftChar(void)
{
if (CursorCol == 0) return;
EditLeftChar();
DeleteRightChar();
}
void InsertBlank(void)
{
int i;
for (i = CursorSel->edco-1 ; i > CursorCol ; --i)
CursorSel->teva[i] = CursorSel->teva[i-1];
CursorSel->teva[CursorCol] = ' ';
}
void ProcChar(int Key)
{
if (CursorSel)
switch (Key)
{
case XK_Up : EditUpLine(); break;
case XK_Left : EditLeftChar(); break;
case XK_Right : EditRightChar(); break;
case XK_Down : EditDownLine(); break;
case XK_Return : EditReturnLine(); break;
case XK_BackSpace: DeleteLeftChar(); break;
case XK_Delete : DeleteRightChar(); break;
case XK_Insert : InsertBlank(); break;
}
}
void LoopGUI(void)
{
int w;
while (1)
{
XNextEvent(display,&WinEvent);
switch (WinEvent.type)
{
case ClientMessage: return;
case MotionNotify : if (OnFrame(0)) ShowOrography();
if (Model == PUMA && OnFrame(1)) ShowModeSelector();
break;
case ButtonRelease: Button1Down = 0; if (OnFrame(0)) ShowOrography(); break;
case ButtonPress : Button1Down = 1;
if (!OnFrame(0) && !OnFrame(1)) OnMouseClick();
case Expose : RedrawControlWindow(); break;
case KeyPress : EdiKeyCode = EdiDecodeKey();
if (EdiKeyCode >= ' ' && EdiKeyCode < 256) EmitChar(EdiKeyCode);
else ProcChar(EdiKeyCode);
RedrawControlWindow();
break;
}
}
}
int CheckEndianess(void)
{
union EndianCheck
{
char b[sizeof(int)];
int i;
} ec;
ec.i = 8;
return (ec.b[0] == 0);
}
int main(int argc, char *argv[])
{
int ia;
for (ia = 1 ; ia < argc ; ++ia)
{
if (!strcmp(argv[ia],"-d")) Debug = 1;
else if (!strcmp(argv[ia],"-i")) cfg_file[0] = 0;
else if (!strcmp(argv[ia],"-h")) ScreenHeight = atoi(argv[++ia]);
else strncpy(cfg_file,argv[1],sizeof(cfg_file));
}
CurrentDate = time(NULL);
BigEndian = CheckEndianess();
InitGUI();
LoopGUI();
return 0;
}
