// AutomataHex.cpp : Defines the entry point for the application. // /* This is a program that implements a 2D cellular automata model of a leaf epidermis. The dependent variable being modeled is the cell water potential (p). Each step considers water movement (or more accurately p changes) as determined by: 1) the p of neighboring cells (if p of a neighbor cell is higher that the cell under consideration, that cell's p increases and the neighbor's drops), 2) water uptake from xylem feeding all epidermal cells, and 3) loss to the air from cells designated as "stomata". 4) Stomata are variable as a function of cell p Cell p values are displayed graphically in the program window as a map with p coded in a gray scale from black (low p) to white (high p). The degree of stomatal opening (the value of flow out through stomata) is indicated using color values from blue through red. The program allows for the setting of all sorts of model, solution method, and display parameters through dialog boxes. */ /* Program variables Name Use a Exponential term coeff as part of the logistic stomatal control function bAuto Boolean variable used with the checkbox in the Display dialog to indicate automatic scaling of the map grayscale colors bStom Boolean variable used with the checkbox in the Display dialog to indicate automatic scaling of the stomata color scale bNewStom Boolean variable used to indicate that stomata locations have been altered bOffset Boolean variable indicating the choice for pleaf as an offset from the meanp border Minimum acceptable distance between stomata and the model edge (while randomizing) cThreadGo Flag to start and stop the continuous thread for "move" cxClient Size of client part of main window cyClient Size of client part of main window cxChar Font data - x size of characters cyChar Font data - y size of characters cxMap Size of map cyMap Size of map cxStart Starting location of map in client window cyStart Starting location of map in client window cxSquare Pixel size of each model cell in the map cySquare Pixel size of each model cell in the map dp Accumulates the various changes in p before they are applied to p Filename String variable with the output file name hBrush Vector for storing the handle to a set of 256 gray-scale brushes iColor Gray scale value used in painting iDimSize Size of model: number of rows and columns iDisplay Map is redrawn every "iDisplay" number of moves iScale Used in converting p to a grayscale value Jout Vector of quantity lost from a cell designated as a stomata J0 Stomatal flow for p = pminj Jmax Max value of stomatal flow kepi Conductance between epidermis cells kin Conductance between epidermis and underlying leaf cells maxp Maximum value of p in the array maxJ Highest outflow value among all stomata meanp Mean value of p in the array minp Minimum value of p in the array minJ Lowest outflow value among all stomata ncells Number of cells in the model ncols Number of columns in the model array nrows Number of rows in the model array nstomata Number of stomata in array p Basic array for storing cell water potentials pause Boolean variable for pausing the moves pleaf p value for bulk leaf pleafoff Offset value to be applied to pleaf pminj p value leading to stomatal flow of J0 pnew Array used to storing new cell p values until the entire new array is done restart Boolean variable indicating need to restart the model s???? Almost all variables have a string variable version with "s" preceeding their name that is used in filling out dialog box edit controls stomX Vector of stomata locations (in columns) stomY Vector of stomata locations (in rows) stomXtemp Temporary storage in case user cancels stomata location changes stomYtemp -- see above -- spacing Minimum acceptable distance between stomata (while randomizing) t Time step Tempborder Temporary storage for border in case user cancels changes TempNstom Temporary storage for nstomata in case user cancels changes Tempspacing Temporary storage for spacing in case user cancels changes TempTint Temporary storage for timer interval in case user cancels a change uTint Timer interval between moves */ #include "stdafx.h" #include "resource.h" #include #include #include #include #include #include #include #include #define MAX_LOADSTRING 100 #define INIT_P 0 #define MAX_NSTOM 20000 // Global Variables: HINSTANCE hInst; // current instance TCHAR szTitle[MAX_LOADSTRING]; // The title bar text TCHAR szCurrentTitle[MAX_PATH]; // Text for updated title bar TCHAR szWindowClass[MAX_LOADSTRING]; // The title bar text double pdwn, pup, dp, spacing, TempSpacing; double kepi, kin, Jmax, J0, a, pminj; double **p, **pnew; double pleaf, pleafoff, maxp, minp, meanp, minJ, maxJ, meanJ; double *Jout, JoutTotal; int *stomX, *stomY, *stomXtemp, *stomYtemp; int nstomata, TempNstom, TempBorder, cxMap, cyMap; int t, border, ncells, nrows, ncols, iDisplay, iDimSize; unsigned int uTint, TempTint; char snstomata[32], snrows[32], sncols[32], spdwn[32], spup[32], sJout[32], sTint[32]; char sminp[32], smaxp[32], sminJ[32], smaxJ[32], sspacing[32], sborder[32], sDisplay[31]; char skepi[32], skin[32], sJmax[32], sJ0[32], sa[32], spminj[32], spleafoff[32]; char Filename[MAX_PATH]; BOOL restart, pause, bAuto, bStom, bNewStom, bOffset, cThreadGo, bDataValid; HANDLE hMutex; HBRUSH hBrush[256]; HWND hWnd; HMENU hMenu; // Foward declarations of functions included in this code module: ATOM MyRegisterClass(HINSTANCE hInstance); BOOL InitInstance(HINSTANCE, int); LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); LRESULT CALLBACK DimensionDlgProc( HWND, UINT, WPARAM, LPARAM ); LRESULT CALLBACK DisplayDlgProc( HWND, UINT, WPARAM, LPARAM ); LRESULT CALLBACK StomataDlgProc( HWND, UINT, WPARAM, LPARAM ); LRESULT CALLBACK ParamsDlgProc( HWND, UINT, WPARAM, LPARAM ); void FreeMem( void ); //Free malloced arrays for p, pnew void Startup( void ); //Allocate arrays and set some initial values void NewStomata( void ); //Reallocate memory for stomata locations void Move( int t ); //Execute one move of model void Randomize( void ); //Randomly select new locations for stomata void MoveFull( void * ); // *param ); //Execute moves as new thread BOOL OpenNewFile( HWND ); //Get file name to open void ReadFileData( void ); //Read data from file void ShowMessageBox( int ); int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { MSG msg; // Initialize global strings LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING); LoadString(hInstance, IDC_SPACE, szWindowClass, MAX_LOADSTRING); MyRegisterClass(hInstance); // Perform application initialization: if (!InitInstance (hInstance, nCmdShow)) { return FALSE; } // Main message loop: while (GetMessage(&msg, NULL, 0, 0)) { TranslateMessage(&msg); DispatchMessage(&msg); } return msg.wParam; } // // FUNCTION: MyRegisterClass() // // PURPOSE: Registers the window class. // // COMMENTS: // // This function and its usage is only necessary if you want this code // to be compatible with Win32 systems prior to the 'RegisterClassEx' // function that was added to Windows 95. It is important to call this function // so that the application will get 'well formed' small icons associated // with it. // ATOM MyRegisterClass(HINSTANCE hInstance) { WNDCLASSEX wcex; wcex.cbSize = sizeof(WNDCLASSEX); wcex.style = CS_HREDRAW | CS_VREDRAW; wcex.lpfnWndProc = (WNDPROC)WndProc; wcex.cbClsExtra = 0; wcex.cbWndExtra = 0; wcex.hInstance = hInstance; wcex.hIcon = LoadIcon(hInstance, (LPCTSTR)IDI_SPACE); wcex.hCursor = LoadCursor(NULL, IDC_ARROW); wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1); wcex.lpszMenuName = (LPCSTR)IDR_MENU1; wcex.lpszClassName = szWindowClass; wcex.hIconSm = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL); return RegisterClassEx(&wcex); } // // FUNCTION: InitInstance(HANDLE, int) // // PURPOSE: Saves instance handle and creates main window // // COMMENTS: // // In this function, we save the instance handle in a global variable and // create and display the main program window. // BOOL InitInstance(HINSTANCE hInstance, int nCmdShow) { // HWND hWnd; hInst = hInstance; // Store instance handle in our global variable hWnd = CreateWindow(szWindowClass, szTitle, WS_CAPTION | WS_SYSMENU | WS_OVERLAPPED | WS_MINIMIZEBOX, CW_USEDEFAULT, 0, 866, 870, NULL, NULL, hInstance, NULL); //Specify window size if (!hWnd) { return FALSE; } ShowWindow(hWnd, nCmdShow); UpdateWindow(hWnd); return TRUE; } // // FUNCTION: WndProc(HWND, unsigned, WORD, LONG) // // PURPOSE: Processes messages for the main window. // // WM_COMMAND - process the application menu // WM_PAINT - Paint the main window // WM_DESTROY - post a quit message and return // // LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { int wmId, wmEvent; PAINTSTRUCT ps; HDC hdc; RECT rt; HBRUSH hbr; TEXTMETRIC lptm; static int cxClient, cyClient, cxChar, cyChar; static int iLength, nxText, nyText, nTimerID; int cxSquare, cySquare, cxStart, cyStart; char PaintBuf[256]; int i, j, iColor, iRed, iGreen, iBlue; float fScale, offsetX, offsetY; FILE *outfile; DWORD dwWaitResult; // HMENU hMenu; static HANDLE hThread; static unsigned threadID; char cMutexName[64]; BOOL bFile; TCHAR szHello[MAX_LOADSTRING]; LoadString(hInst, IDS_HELLO, szHello, MAX_LOADSTRING); switch (message) { case WM_COMMAND: wmId = LOWORD(wParam); wmEvent = HIWORD(wParam); // Parse the menu selections: switch (wmId) { case IDM_EXIT: DestroyWindow(hWnd); break; case IDM_START: //Start run using timer, disable menu items hMenu = GetMenu( hWnd ); EnableMenuItem( hMenu, IDM_START, MF_GRAYED ); EnableMenuItem( hMenu, IDM_STEP, MF_GRAYED ); EnableMenuItem( hMenu, IDM_RESTART, MF_GRAYED ); EnableMenuItem( hMenu, IDM_SAVE, MF_GRAYED ); EnableMenuItem( hMenu, IDM_DIM, MF_GRAYED ); EnableMenuItem( hMenu, IDM_STOMATA, MF_GRAYED ); EnableMenuItem( hMenu, IDM_PARAMS, MF_GRAYED ); EnableMenuItem( hMenu, IDM_STARTFULL, MF_GRAYED ); EnableMenuItem( hMenu, IDM_STOPFULL, MF_GRAYED ); DrawMenuBar( hWnd ); pause = FALSE; //Reset pause allowing move to advance break; case IDM_STOP: //Stop run driven by timer, enable menu items pause = TRUE; //Set pause, stopping advancement hMenu = GetMenu( hWnd ); EnableMenuItem( hMenu, IDM_START, MF_ENABLED ); EnableMenuItem( hMenu, IDM_STEP, MF_ENABLED ); EnableMenuItem( hMenu, IDM_RESTART, MF_ENABLED ); EnableMenuItem( hMenu, IDM_SAVE, MF_ENABLED ); EnableMenuItem( hMenu, IDM_DIM, MF_ENABLED ); EnableMenuItem( hMenu, IDM_STOMATA, MF_ENABLED ); EnableMenuItem( hMenu, IDM_PARAMS, MF_ENABLED ); EnableMenuItem( hMenu, IDM_STARTFULL, MF_ENABLED ); EnableMenuItem( hMenu, IDM_STOPFULL, MF_ENABLED ); DrawMenuBar( hWnd ); InvalidateRect( hWnd, NULL, FALSE ); break; case IDM_STEP: //Advance model one step Move( t ); t++; InvalidateRect( hWnd, NULL, FALSE ); break; case IDM_RESTART: FreeMem(); //Reallocate memory Startup(); //Allocate memory and reset p InvalidateRect( hWnd, NULL, FALSE ); break; case IDM_STARTFULL: //Launch thread to run continuously hMenu = GetMenu( hWnd ); //Disable menus EnableMenuItem( hMenu, IDM_START, MF_GRAYED ); EnableMenuItem( hMenu, IDM_STOP, MF_GRAYED ); EnableMenuItem( hMenu, IDM_STEP, MF_GRAYED ); EnableMenuItem( hMenu, IDM_RESTART, MF_GRAYED ); EnableMenuItem( hMenu, IDM_SAVE, MF_GRAYED ); EnableMenuItem( hMenu, IDM_DIM, MF_GRAYED ); EnableMenuItem( hMenu, IDM_STOMATA, MF_GRAYED ); EnableMenuItem( hMenu, IDM_PARAMS, MF_GRAYED ); EnableMenuItem( hMenu, IDM_STARTFULL, MF_GRAYED ); DrawMenuBar( hWnd ); cThreadGo = TRUE; RedrawWindow( hWnd, NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW ); _beginthread( MoveFull, 0, NULL ); //(void *) &hWnd ); break; case IDM_STOPFULL: cThreadGo = FALSE; //Set flag to stop thread break; //Enable menus in MoveFull function case IDM_SAVE: outfile = fopen( Filename, "w" ); //Write current p array to file fprintf( outfile, "%i %i %i %i %i\n", cxMap, cyMap, nrows, ncols, t ); fprintf( outfile, "%6.4e %6.4e\n", kepi, kin ); fprintf( outfile, "%i %i %5.2f %8.4f %8.4f %8.4f %8.4f %8.4f\n", nstomata, border, spacing, Jmax, J0, a, pminj, pleafoff); for( i=0; i= maxp ) iColor = 255; //make white else iColor = (int)( (p[i][j] - minp) * fScale ); //scale color FillRect( hdc, &rt, hBrush[iColor] ); } } offsetY = cySquare / 2 - 2; offsetX = cxSquare / 2 - 2; for( i=0; iMAX_NSTOM) || (nstomata>iDimSize*iDimSize) ) { MessageBox( NULL, "Too many stomata!!", "Error", MB_OK ); bError = TRUE; break; } GetDlgItemText( hDlg, IDC_STOMX, MLEBufferX, 5*MAX_NSTOM ); //Read MLE data pBuffIndex = MLEBufferX; for( i=0; i=ncols) ) { MessageBox( NULL, "Illegal location for stomata!!", "Error", MB_OK ); bError = TRUE; } } GetDlgItemText( hDlg, IDC_STOMY, MLEBufferY, 5*MAX_NSTOM ); pBuffIndex = MLEBufferY; for( i=0; i=nrows) ) { MessageBox( NULL, "Illegal location for stomata!!", "Error", MB_OK ); bError = TRUE; } } if( !bError ) EndDialog(hDlg, IDOK); break; case IDCANCEL: restart = FALSE; for( i=0; iMAX_NSTOM) || (nstomata>iDimSize*iDimSize) ) { MessageBox( NULL, "Too many stomata!!", "Error", MB_OK ); bError = TRUE; break; } GetDlgItemText( hDlg, IDC_SPACING, sspacing, 31 ); spacing = (double) atof( sspacing ); GetDlgItemText( hDlg, IDC_BORDER, sborder, 31 ); border = atoi( sborder ); NewStomata(); //Reallocate memory Randomize(); //Pick new locations memset( &MLEBufferX, 0x20, 5*MAX_NSTOM ); //Write new locations pBuffIndex = MLEBufferX; for( i=0; i0 maxyint = nrows-1-border; minxint = border; minyint = border; i=0; trap = 0; do { x = rand() / (RAND_MAX + 1.0); //Guess location xint = (int) floor( (maxxint-minxint+1) * x ) + minxint; y = rand() / (RAND_MAX + 1.0); yint = (int) floor( (maxyint-minyint+1) * y ) + minyint; bUnique = TRUE; for( j=0; j= 1000000L ) MessageBox( NULL, "Randomize Failure!!", "Error", MB_OK ); return; } BOOL OpenNewFile( HWND hWnd ) { OPENFILENAME OpenFileName; char szFile[MAX_PATH]; char CurrentDir[MAX_PATH]; szFile[0] = 0; GetCurrentDirectory( MAX_PATH, CurrentDir ); OpenFileName.lStructSize = sizeof( OPENFILENAME ); OpenFileName.hwndOwner = hWnd; OpenFileName.lpstrFilter = "Data Files\0*.dat\0\0"; OpenFileName.lpstrCustomFilter = NULL; OpenFileName.nMaxCustFilter = 0; OpenFileName.nFilterIndex = 0; OpenFileName.lpstrFile = szFile; OpenFileName.nMaxFile = sizeof( szFile ); OpenFileName.lpstrFileTitle = NULL; OpenFileName.nMaxFileTitle = 0; OpenFileName.lpstrInitialDir = CurrentDir; OpenFileName.lpstrTitle = "Open a file"; OpenFileName.nFileOffset = 0; OpenFileName.nFileExtension = 0; OpenFileName.lpstrDefExt = NULL; OpenFileName.lCustData = 0; OpenFileName.lpfnHook = NULL; OpenFileName.lpTemplateName = NULL; OpenFileName.Flags = OFN_EXPLORER; if( GetOpenFileName( &OpenFileName ) ) { strcpy( Filename, szFile ); return TRUE; } else return FALSE; } void ReadFileData( void ) { FILE *infile; int i, tempncols; bDataValid = FALSE; if( (infile = fopen( Filename, "r" )) == NULL ) { ShowMessageBox( 1 ); return; } if( fscanf( infile, "%i %i %i %i %i", &cxMap, &cyMap, &nrows, &tempncols, &t ) != 5 ) { ShowMessageBox( 2 ); fclose( infile ); return; } if( fscanf( infile, "%le %le", &kepi, &kin ) != 2 ) { ShowMessageBox( 2 ); fclose( infile ); return; } if( fscanf( infile, "%i %i %lf %lf %lf %lf %lf %lf\n", &nstomata, &border, &spacing, &Jmax, &J0, &a, &pminj, &pleafoff ) != 8 ) { ShowMessageBox( 2 ); fclose( infile ); return; } NewStomata(); FreeMem(); //Free calls must use the old value of ncols ncols = tempncols; //Now, new mallocs use the newly read value from the file Startup(); for( i=0; i