epyt-flow 0.1.0__py3-none-any.whl

epyt_flow/EPANET/EPANET/SRC_engines/main.c

@@ -0,0 +1,93 @@
+/*
+ ******************************************************************************
+ Project:      OWA EPANET
+ Version:      2.2
+ Module:       main.c
+ Description:  main stub for a command line executable version of EPANET
+ Authors:      see AUTHORS
+ Copyright:    see AUTHORS
+ License:      see LICENSE
+ Last Updated: 12/07/2018
+ ******************************************************************************
+*/
+
+#include <stdio.h>
+#include "epanet2.h"
+
+void  writeConsole(char *s)
+{
+    fprintf(stdout, "\r%s", s);
+    fflush(stdout);
+}
+
+int  main(int argc, char *argv[])
+/*--------------------------------------------------------------
+ **  Input:   argc    = number of command line arguments
+ **           *argv[] = array of command line arguments
+ **  Output:  none
+ **  Purpose: main program stub for command line EPANET
+ **
+ **  Command line for stand-alone operation is:
+ **    progname f1  f2  f3
+ **  where progname = name of executable this code was compiled to,
+ **  f1 = name of input file,
+ **  f2 = name of report file
+ **  f3 = name of binary output file (optional).
+ **--------------------------------------------------------------
+ */
+{
+    char *f1,*f2,*f3;
+    char blank[] = "";
+    char errmsg[256] = "";
+    int  errcode;
+    int  version;
+    int  major;
+    int  minor;
+    int  patch;
+    
+    // Check for proper number of command line arguments
+    if (argc < 3)
+    {
+        printf(
+    "\nUsage:\n %s <input_filename> <report_filename> [<binary_filename>]\n",
+        argv[0]);
+        return 0;
+    }
+
+    // Get version number and display in Major.Minor.Patch format
+    ENgetversion(&version);
+    major = version/10000;
+    minor = (version%10000)/100;
+    patch = version%100;
+    printf("\n... Running EPANET Version %d.%d.%d\n", major, minor, patch);
+  
+    // Assign pointers to file names
+    f1 = argv[1];
+    f2 = argv[2];
+    if (argc > 3) f3 = argv[3];
+    else          f3 = blank;
+
+    // Run EPANET
+    errcode = ENepanet(f1, f2, f3, &writeConsole);
+
+    // Blank out the last progress message
+    printf("\r                                                               ");
+
+    // Check for errors/warnings and report accordingly
+    if (errcode == 0)
+    {
+        printf("\n... EPANET ran successfully.\n");
+        return 0;
+    }
+    else if (errcode < 100)
+    {
+        printf("\n... EPANET ran with warnings - check the Status Report.\n");
+        return 0;
+    }
+    else
+    {
+        ENgeterror(errcode, errmsg, 255);
+        printf("\n... EPANET failed with %s.\n", errmsg);
+        return 100;
+    }
+}

epyt_flow/EPANET/EPANET/SRC_engines/mempool.c

@@ -0,0 +1,142 @@
+/*
+ ******************************************************************************
+ Project:      OWA EPANET
+ Version:      2.2
+ Module:       mempool.c
+ Description:  a simple fast poooled memory allocation package
+ Authors:      see AUTHORS
+ Copyright:    see AUTHORS
+ License:      see LICENSE
+ Last Updated: 05/15/2019
+
+ This module is based code by Steve Hill in Graphics Gems III,
+ David Kirk (ed.), Academic Press, Boston, MA, 1992
+ ******************************************************************************
+*/
+
+#include <stdlib.h>
+
+#include "mempool.h"
+
+/*
+**  ALLOC_BLOCK_SIZE - adjust this size to suit your installation - it
+**  should be reasonably large otherwise you will be mallocing a lot.
+*/
+
+#define ALLOC_BLOCK_SIZE   64000       /*(62*1024)*/
+
+struct MemBlock
+{
+    struct MemBlock *next;   // Next block
+    char            *block,  // Start of block
+                    *free,   // Next free position in block
+                    *end;    // block + block size
+};
+
+struct Mempool
+{
+    struct MemBlock *first;
+    struct MemBlock *current;
+};
+
+static struct MemBlock* createMemBlock()
+{
+    struct MemBlock* memBlock = malloc(sizeof(struct MemBlock));
+    if (memBlock)
+    {
+        memBlock->block = malloc(ALLOC_BLOCK_SIZE * sizeof(char));
+        if (memBlock->block == NULL)
+        {
+            free(memBlock);
+            return NULL;
+        }
+        memBlock->free = memBlock->block;
+        memBlock->next = NULL;
+        memBlock->end = memBlock->block + ALLOC_BLOCK_SIZE;
+    }
+    return memBlock;
+}
+
+
+static void deleteMemBlock(struct MemBlock* memBlock)
+{
+    free(memBlock->block);
+    free(memBlock);
+}
+
+
+struct Mempool * mempool_create()
+{
+    struct Mempool *mempool;
+    mempool = (struct Mempool *)malloc(sizeof(struct Mempool));
+    if (mempool == NULL) return NULL;
+    mempool->first = createMemBlock();
+    mempool->current = mempool->first;
+    if (mempool->first == NULL) return NULL;
+    return mempool;
+}
+
+void mempool_delete(struct Mempool *mempool)
+{
+    if (mempool == NULL) return;
+    while (mempool->first)
+    {
+        mempool->current = mempool->first->next;
+        deleteMemBlock(mempool->first);
+        mempool->first = mempool->current;
+    }
+    free(mempool);
+    mempool = NULL;
+}
+
+void mempool_reset(struct Mempool *mempool)
+{
+    mempool->current = mempool->first;
+    mempool->current->free = mempool->current->block;
+}
+
+
+char * mempool_alloc(struct Mempool *mempool, size_t size)
+{
+    char* ptr;
+
+    /*
+    **  Align to 4 byte boundary - should be ok for most machines.
+    **  Change this if your machine has weird alignment requirements.
+    */
+    size = (size + 3) & 0xfffffffc;
+
+    if (!mempool->current) return NULL;
+    ptr = mempool->current->free;
+    mempool->current->free += size;
+
+    // Check if the current block is exhausted
+
+    if (mempool->current->free >= mempool->current->end)
+    {
+        // Is the next block already allocated?
+
+        if (mempool->current->next)
+        {
+            // re-use block
+            mempool->current->next->free = mempool->current->next->block;
+            mempool->current = mempool->current->next;
+        }
+        else
+        {
+            // extend the pool with a new block
+            mempool->current->next = createMemBlock();
+            if (!mempool->current->next) return NULL;
+            mempool->current = mempool->current->next;
+        }
+
+        // set ptr to the first location in the next block
+
+        ptr = mempool->current->free;
+        mempool->current->free += size;
+    }
+
+    // Return pointer to allocated memory
+
+    return ptr;
+}

epyt_flow/EPANET/EPANET/SRC_engines/mempool.h

@@ -0,0 +1,24 @@
+/*
+ ******************************************************************************
+ Project:      OWA EPANET
+ Version:      2.2
+ Module:       mempool.h
+ Description:  header for a simple pooled memory allocator
+ Authors:      see AUTHORS
+ Copyright:    see AUTHORS
+ License:      see LICENSE
+ Last Updated: 11/27/2018
+ ******************************************************************************
+*/
+
+#ifndef MEMPOOL_H
+#define MEMPOOL_H
+
+struct Mempool;
+
+struct Mempool * mempool_create();
+void   mempool_delete(struct Mempool *mempool);
+void   mempool_reset(struct Mempool *mempool);
+char * mempool_alloc(struct Mempool *mempool, size_t size);
+
+#endif