psr-factory 5.0.0b10__py3-none-win_amd64.whl → 5.0.0b13__py3-none-win_amd64.whl

psr/execqueue/server.py

@@ -0,0 +1,383 @@
+import hashlib
+import queue
+import shutil
+import sys
+import threading
+import time
+import zipfile
+from dotenv import load_dotenv
+from flask import (
+    Flask,
+    request,
+    jsonify,
+    send_file
+)
+import ulid
+
+
+import psr.runner
+import psr.cloud
+
+from psr.execqueue.config import *
+from psr.execqueue import db
+
+_execution_queue = queue.Queue()
+_cloud_upload_queue = queue.Queue()
+
+
+os.makedirs(UPLOADS_FOLDER, exist_ok=True)
+os.makedirs(LOCAL_RESULTS_FOLDER, exist_ok=True)
+os.makedirs(CLOUD_RESULTS_FOLDER, exist_ok=True)
+os.makedirs(TEMPORARY_UPLOAD_FOLDER, exist_ok=True)
+
+
+load_dotenv()
+
+
+try:
+    client = psr.cloud.Client(cluster=psrcloud_cluster, verbose=True)
+except psr.cloud.CloudInputError as e:
+    print(f"Error connecting to PSR Cloud. Check user credentials: {e}")
+    exit(1)
+
+_cloud_execution_case_map = {}
+
+app = Flask(__name__)
+session = None
+
+
+def get_file_checksum(file_path: str) -> str:
+    with open(file_path, 'rb') as file:
+        return hashlib.md5(file.read()).hexdigest()
+
+
+def run_local_case(execution_id: str, case_path: str):
+    global session
+    success = False
+    try:
+        psr.runner.run_sddp(case_path, sddp_path, parallel_run=False)
+        success = True
+    except RuntimeError as e:
+        print(f"Error running {execution_id}: {e}")
+
+    status = db.LOCAL_EXECUTION_FINISHED if success else db.LOCAL_EXECUTION_ERROR
+    db.update_local_execution_status(session, execution_id, status)
+
+
+def initialize_db():
+    session, engine = db.initialize()
+    return session
+
+
+def run_cloud_case(execution_id: str, case_path: str):
+    global client
+    # Run the case
+    case = psr.cloud.Case(
+        name="LSEG Server "+ execution_id,
+        data_path=case_path,
+        program="SDDP",
+        program_version = "17.3.9",
+        execution_type="Default",
+        memory_per_process_ratio='2:1',
+        price_optimized=False,
+        number_of_processes=64,
+        repository_duration=1,
+    )
+    case_id = client.run_case(case)
+
+    return str(case_id)
+
+
+def process_local_execution_queue():
+    global session
+    while True:
+        execution_id, case_id = _execution_queue.get()
+        try:
+            print(f"Processing {execution_id}...")
+            # Unzip the file
+            execution_extraction_path = os.path.join(LOCAL_RESULTS_FOLDER, execution_id)
+            os.makedirs(execution_extraction_path, exist_ok=True)
+
+            zip_upload_path = os.path.join(UPLOADS_FOLDER, case_id + ".zip")
+
+            with zipfile.ZipFile(zip_upload_path, 'r') as zip_ref:
+                zip_ref.extractall(execution_extraction_path)
+            # Run SDDP
+            run_local_case(execution_id, execution_extraction_path)
+
+        except Exception as e:
+            print(f"Error processing {execution_id}: {e}")
+        finally:
+            _execution_queue.task_done()
+
+
+threading.Thread(target=process_local_execution_queue, daemon=True).start()
+
+
+def process_cloud_execution_queue():
+    global client
+    global session
+    while True:
+        cloud_upload_id, case_id = _cloud_upload_queue.get()
+        try:
+            print(f"Processing {cloud_upload_id}...")
+            # Unzip the file
+            zip_upload_path = os.path.join(UPLOADS_FOLDER, case_id + ".zip")
+            tmp_extraction_path = os.path.join(TEMPORARY_UPLOAD_FOLDER, cloud_upload_id)
+
+            os.makedirs(tmp_extraction_path, exist_ok=True)
+            with zipfile.ZipFile(zip_upload_path, 'r') as zip_ref:
+                zip_ref.extractall(tmp_extraction_path)
+
+            # Run SDDP
+            repository_id = run_cloud_case(cloud_upload_id, tmp_extraction_path)
+
+            #delete the extraction path folder recursively
+            shutil.rmtree(tmp_extraction_path)
+
+            execution_extraction_path = os.path.join(CLOUD_RESULTS_FOLDER, repository_id)
+            os.makedirs(execution_extraction_path, exist_ok=True)
+            with zipfile.ZipFile(zip_upload_path, 'r') as zip_ref:
+                zip_ref.extractall(execution_extraction_path)
+
+            db.register_cloud_execution(session, repository_id, cloud_upload_id, case_id)
+
+        except Exception as e:
+            print(f"Error processing {cloud_upload_id}: {e}")
+        finally:
+            _cloud_upload_queue.task_done()
+
+
+threading.Thread(target=process_cloud_execution_queue, daemon=True).start()
+
+
+def monitor_cloud_runs():
+    global client
+    global session
+
+    #wait for cloud upload queue to be empty
+    while not _cloud_upload_queue.empty():
+        time.sleep(10)
+
+    while True:
+        if session:
+            #check running executions
+            for cloud_execution in db.get_runing_cloud_executions(session):
+                case_id = cloud_execution.repository_id
+                print(f"Checking status of {case_id}...")
+                status, status_msg = client.get_status(case_id)
+                if status in psr.cloud.FAULTY_TERMINATION_STATUS:
+                    print(f"Execution {case_id} finished with errors")
+                    db.update_cloud_execution_status(session, case_id, db.CloudStatus.ERROR.value)
+                elif status == psr.cloud.ExecutionStatus.SUCCESS:
+                    print(f"Execution {case_id} finished successfully")
+                    db.update_cloud_execution_status(session, case_id, db.CloudStatus.FINISHED.value)
+
+            #download finished executions
+            for cloud_execution in db.get_cloud_finished_executions(session):
+                repository_id = cloud_execution.repository_id
+                print(f"Downloading results for {repository_id}...")
+                result_path = os.path.join(CLOUD_RESULTS_FOLDER, str(repository_id))
+                client.download_results(repository_id, result_path)
+                db.update_cloud_execution_status(session, repository_id, db.CloudStatus.RESULTS_AVAILABLE.value)
+        else:
+            print("Database not initialized. Retrying in 30s...")
+        time.sleep(30)
+
+threading.Thread(target=monitor_cloud_runs, daemon=True).start()
+
+@app.route('/upload', methods=['POST'])
+def upload_file():
+    global session
+    if 'file' not in request.files:
+        return jsonify({'error': 'No file part'}), 400
+
+    file = request.files['file']
+    if file.filename == '':
+        return jsonify({'error': 'No selected file'}), 400
+
+    case_id = str(ulid.ULID())
+    zip_path = os.path.join(UPLOADS_FOLDER, f"{case_id}.zip")
+    file.save(zip_path)
+
+    checksum = get_file_checksum(zip_path)
+    db.register_case(session, case_id, checksum)
+
+    return jsonify({'case_id': case_id}), 200
+
+
+# route to run an uploaded file
+@app.route('/run', methods=['POST'])
+def run_endpoint():
+    global session
+    cloud_execution = request.form.get('cloud_execution', 'false').lower() == 'true'
+    case_id = request.form.get('case_id')
+
+    if not case_id:
+        return jsonify({'error': 'Case ID not provided'}), 400
+
+    zip_case_path = os.path.join(UPLOADS_FOLDER, f"{case_id}.zip")
+    if not os.path.exists(zip_case_path):
+        return jsonify({'error': 'Upload file for this case ID not found'}), 404
+
+    if cloud_execution:
+        cloud_upload_id = str(ulid.ULID())
+        _cloud_upload_queue.put((cloud_upload_id, case_id))
+
+        db.register_cloud_upload(session, case_id, cloud_upload_id)
+
+        return jsonify({'case_id': case_id, 'cloud_upload_id': cloud_upload_id}), 200
+    else:
+        execution_id = str(ulid.ULID())
+        _execution_queue.put((execution_id, case_id))
+
+        db.register_local_execution(session, case_id, execution_id)
+
+        return jsonify({'case_id': case_id, 'execution_id': execution_id}), 200
+
+
+@app.route('/upload_and_run', methods=['POST'])
+def upload_and_run_file():
+    global session
+    if 'file' not in request.files:
+        return jsonify({'error': 'No file part'}), 400
+
+    file = request.files['file']
+    if file.filename == '':
+        return jsonify({'error': 'No selected file'}), 400
+    
+    cloud_execution = request.form.get('cloud_execution', 'false').lower() == 'true'
+
+    case_id = str(ulid.ULID())
+    zip_path = os.path.join(UPLOADS_FOLDER, f"{case_id}.zip")
+    file.save(zip_path)
+    db.register_case(session, case_id, get_file_checksum(zip_path))
+
+    if cloud_execution:
+        cloud_upload_id = str(ulid.ULID())
+        _cloud_upload_queue.put((cloud_upload_id, case_id))
+        db.register_cloud_upload(session, case_id, cloud_upload_id)
+        return jsonify({'case_id': case_id, 'cloud_upload_id': cloud_upload_id}), 200
+    else:
+        execution_id = str(ulid.ULID())
+        _execution_queue.put((execution_id, case_id))
+        db.register_local_execution(session, case_id, execution_id)
+        return jsonify({'case_id': case_id, 'execution_id': execution_id}), 200
+
+
+@app.route('/status/<execution_id>', methods=['GET'])
+def get_status(execution_id):
+    """
+    Get the status of an execution
+    ---
+    tags:
+      - Execution
+    parameters:
+      - name: execution_id
+        in: path
+        type: string
+        required: true
+        description: The ID of the execution
+    responses:
+      200:
+        description: Execution status
+        schema:
+          type: string
+      404:
+        description: Execution ID not found
+    """ 
+    global client
+    global session
+    cloud_execution = request.form.get('cloud_execution', 'false').lower() == 'true'
+    return_status_id = request.form.get('return_status_id', 'false').lower() == 'true'
+
+    if cloud_execution:
+        repository_id = db.get_repository_id_from_cloud_upload_id(session, execution_id)
+        if repository_id is None:
+            return jsonify({'error': 'Execution ID not found in Cloud'}), 404
+        status = db.get_cloud_execution_status(session, repository_id)
+        if return_status_id:
+            return jsonify({'status_id': status}), 200
+        if status == db.CloudStatus.ERROR.value:
+            return jsonify({'status': 'Execution finished with errors'}), 200
+        elif status == db.CloudStatus.RUNNING.value:
+            return jsonify({'status': 'Execution not finished yet'}), 200
+        elif status == db.CloudStatus.FINISHED.value:
+            return jsonify({'status': 'Execution finished, but download not yet downloaded from Cloud server'}), 200
+        elif status == db.CloudStatus.RESULTS_AVAILABLE.value:
+            return jsonify({'status': 'Execution finished and results are available to download'}), 200
+
+@app.route('/results/<execution_id>', methods=['GET'])
+def get_results(execution_id: str):
+    global session
+    global client
+    cloud_execution = request.form.get('cloud_execution', 'false').lower() == 'true'
+
+    if cloud_execution:
+        repository_id = db.get_repository_id_from_cloud_upload_id(session, execution_id)
+        if repository_id is None:
+            return jsonify({'error': 'Execution ID not found in Cloud'}),
+        status = db.get_cloud_execution_status(session, execution_id)
+
+        if status == db.CloudStatus.ERROR:
+            return jsonify({'error': 'Execution Finished with errors'}), 401
+        elif status == db.CloudStatus.RUNNING:
+            return jsonify({'error': 'Execution not finished yet'}), 402
+        elif status == db.CloudStatus.FINISHED:
+            return jsonify({'error': 'Results not available yet'}), 403
+        else:
+            #fazer download da pasta do resultado
+            result_path = os.path.join(CLOUD_RESULTS_FOLDER, str(repository_id))
+            if not os.path.exists(result_path):
+                return jsonify({'error': 'Execution result folder not found'}), 404
+            result_files = os.listdir(result_path)
+            return jsonify({'execution_id': repository_id, 'files': result_files}), 200
+    else:
+        status = db.get_local_execution_status(session, execution_id)
+        if status == db.LOCAL_EXECUTION_ERROR:
+            return jsonify({'error': 'Execution finished with errors'}), 401
+        if status != db.LOCAL_EXECUTION_FINISHED:
+            return jsonify({'error': 'Execution not finished yet'}), 402
+        result_path = os.path.join(LOCAL_RESULTS_FOLDER, execution_id)
+        if not os.path.exists(result_path):
+            return jsonify({'error': 'Execution result folder not found'}), 404
+    result_files = os.listdir(result_path)
+    return jsonify({'execution_id': execution_id, 'files': result_files}), 200
+
+
+@app.route('/results/<execution_id>/<file>', methods=['GET'])
+def download_file(execution_id: str, file):
+    global session
+
+    cloud_execution = request.form.get('cloud_execution', 'false').lower() == 'true'
+    
+    if cloud_execution:
+        repository_id = db.get_repository_id_from_cloud_upload_id(session, execution_id)
+        result_path = os.path.join(CLOUD_RESULTS_FOLDER, str(repository_id))
+    else:
+        result_path = os.path.join(LOCAL_RESULTS_FOLDER, execution_id)
+    if not os.path.exists(result_path):
+        return jsonify({'error': 'Execution result folder not found'}), 404
+
+    file_path = os.path.join(result_path, file)
+    if not os.path.exists(file_path):
+        return jsonify({'error': 'File not found'}), 404
+
+    try:
+        return send_file(file_path, as_attachment=True)
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+
+if __name__ == '__main__':
+    print("Starting server...")
+    session = initialize_db()
+    try:
+        app.run(debug=FLASK_DEBUG,
+                port=settings.get("port", DEFAULT_PORT),
+                threaded=True,
+                use_reloader=False,)
+    except Exception as e:
+        print(f"Error starting server: {e}")
+        sys.exit(1)
+

psr/execqueue/watcher.py

@@ -0,0 +1,128 @@
+import os
+import time
+import shutil
+import logging
+import sqlite3
+from datetime import datetime
+from dotenv import load_dotenv
+import psr.execqueue.client as execqueue
+
+load_dotenv()
+SERVER_URL = os.getenv("SERVER_URL", "http://127.0.0.1:5000")
+WATCH_DIR = os.getenv("WATCH_DIR")
+PROCESSED_DIR = os.getenv("PROCESSED_DIR")
+RESULTS_DIR = os.getenv("RESULTS_DIR", "results")
+SLEEP_SECONDS = int(os.getenv("WATCHER_SLEEP", "30"))
+DB_PATH = os.getenv("WATCHER_DB_PATH", "watcher.sqlite")
+
+
+def _init_db():
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS processed_files (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            filename TEXT NOT NULL,
+            cloud_upload_id TEXT NOT NULL,
+            processed_at TEXT NOT NULL,
+            downloaded INTEGER NOT NULL DEFAULT 0
+        )
+    """)
+    conn.commit()
+    conn.close()
+
+
+def _log_to_db(filename, cloud_upload_id):
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute(
+        "INSERT INTO processed_files (filename, cloud_upload_id, processed_at, downloaded) VALUES (?, ?, ?, ?)",
+        (filename, cloud_upload_id, datetime.now().isoformat(), 0)
+    )
+    conn.commit()
+    conn.close()
+
+
+def _process_zip_files():
+    for filename in os.listdir(WATCH_DIR):
+        if filename.lower().endswith('.zip'):
+            zip_path = os.path.join(WATCH_DIR, filename)
+            logging.info(f"zip file found: {zip_path}")
+
+            case_id = execqueue.upload_case_file(zip_path, SERVER_URL)
+            if not case_id:
+                logging.error(f"Failed uploading file {zip_path}")
+                continue
+
+            cloud_upload_id = execqueue.run_case(case_id, SERVER_URL, cloud_execution=True)
+            if not cloud_upload_id:
+                logging.error(f"Failed executing case {case_id} with {zip_path}")
+                continue
+
+            logging.info(f"File {filename} uploaded and execution started. Cloud Upload ID: {cloud_upload_id}")
+            _log_to_db(filename, cloud_upload_id)
+            dest_path = os.path.join(PROCESSED_DIR, filename)
+            shutil.move(zip_path, dest_path)
+            logging.info(f"File {filename} moved to {PROCESSED_DIR}")
+
+
+def _check_and_download_results():
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute("SELECT id, filename, cloud_upload_id FROM processed_files WHERE downloaded=0")
+    rows = cursor.fetchall()
+    for row in rows:
+        record_id, filename, cloud_upload_id = row
+        status = execqueue.get_execution_status(cloud_upload_id, SERVER_URL, cloud_execution=True, return_status_id=True)
+        if status == "5" or status == 5:
+            files = execqueue.get_results(cloud_upload_id, SERVER_URL, cloud_execution=True)
+            if files:
+                base_filename = os.path.splitext(filename)[0]
+                download_folder_name = f"{base_filename}-{cloud_upload_id}"
+                download_path = os.path.join(RESULTS_DIR, download_folder_name)
+                os.makedirs(download_path, exist_ok=True)
+                for file in files:
+                    execqueue.download_execution_file(cloud_upload_id, SERVER_URL, file, download_path,
+                                                   cloud_execution=True)
+                # Update downloaded flag
+                cursor.execute("UPDATE processed_files SET downloaded=1 WHERE id=?", (record_id,))
+                conn.commit()
+                logging.info(f"Results of {cloud_upload_id} downloaded to {download_path}")
+        elif status == "4" or status == 4:
+            logging.info(f"Execution {cloud_upload_id} is finished with errors.")
+            cursor.execute("UPDATE processed_files SET downloaded=4 WHERE id=?", (record_id,))
+            conn.commit()
+    conn.close()
+
+
+if __name__ == "__main__":
+    if not WATCH_DIR or not PROCESSED_DIR:
+        print("WATCH_DIR and PROCESSED_DIR must be set as environment variables or in a .env file")
+        exit(1)
+
+    LOG_FILE = os.path.join(os.getcwd(), "watcher.log")
+    logging.basicConfig(
+        filename=LOG_FILE,
+        level=logging.INFO,
+        format='%(asctime)s - %(levelname)s - %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S'
+    )
+    # log to standard output as well
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.INFO)
+    logging.getLogger().addHandler(console_handler)
+
+    os.makedirs(WATCH_DIR, exist_ok=True)
+    os.makedirs(PROCESSED_DIR, exist_ok=True)
+    os.makedirs(RESULTS_DIR, exist_ok=True)
+    _init_db()
+    logging.info(f"Case watcher started. Monitoring directory for SDDP cases: {WATCH_DIR}")
+
+    while True:
+        try:
+            _check_and_download_results()
+            _process_zip_files()
+
+        except Exception as e:
+            logging.error(f"Watcher error: {e}", exc_info=True)
+        time.sleep(SLEEP_SECONDS)

psr/factory/__init__.py

@@ -2,6 +2,6 @@
 # Unauthorized copying of this file, via any medium is strictly prohibited
 # Proprietary and confidential
 
-__version__ = "5.0.0b10"
+__version__ = "5.0.0b13"
 
 from .api import *

psr/factory/api.py

@@ -173,18 +173,6 @@ def build_version() -> str:
     return _version_short()
 
 
-def diagnostics() -> str:
-    """Run diagnostics and returns the results as text.
-    Use for troubleshoot and debug purposes."""
-    _check_loaded()
-    size = 1000
-    buffer = ctypes.create_string_buffer(size)
-    status = factorylib.lib.psrd_diagnostics(buffer, size)
-    if status == 0:
-        return _from_c_str(buffer.value)
-    return ""
-
-
 def get_log_level() -> LogLevel:
     """Get log level."""
     _check_loaded()
@@ -206,14 +194,57 @@ def set_log_level(log_level: LogLevel):
         raise FactoryException("Error setting log level")
 
 
+def get_log_file_path() -> str:
+    """Get log file path."""
+    _check_loaded()
+    error = Error()
+    size = 1000
+    buffer = ctypes.create_string_buffer(size)
+    code = factorylib.lib.psrd_get_log_file_path(buffer, size, error.handler())
+    if code != 0:
+        raise FactoryException("Error getting log file path")
+    return _from_c_str(buffer.value)
+
+
 def set_debug_mode(value: Union[bool, int]):
+    warnings.warn(DeprecationWarning("set_debug_mode is deprecated, use set_diagnostics_mode instead."))
+    set_diagnostics_mode(value)
+
+
+def set_diagnostics_mode(value: Union[bool, int]):
     """Set debug mode."""
     _check_loaded()
     if isinstance(value, bool):
         value = 1 if value else 0
-    code = factorylib.lib.psrd_set_debug_mode(value)
+    code = factorylib.lib.psrd_set_diagnostics_mode(value)
     if code != 0:
-        raise FactoryException("Error setting debug mode")
+        raise FactoryException("Error setting diagnostics mode")
+
+
+def diagnostics() -> str:
+    global _initialized
+    global _initialized_lock
+    with _initialized_lock:
+        """Get diagnostics information."""
+        py_diagnostics = f"Python version: {sys.version}\n" \
+                            f"Python encoding: {sys.getdefaultencoding()}\n" \
+                            f"Python locale: {locale.getlocale()}\n" \
+                            f"Operating system: {sys.platform}\n" \
+                            f"Operating system encoding: {locale.getpreferredencoding()}\n" \
+                            f"Module path: {os.path.abspath(os.path.dirname(__file__))}\n" \
+                            f"Working directory: {os.getcwd()}\n"
+
+        _check_loaded()
+        error = Error()
+        size = 10000
+        buffer = ctypes.create_string_buffer(size)
+        module_path = os.path.dirname(__file__)
+        factorylib.lib.psrd_diagnostics(_c_str(module_path), _bytes(module_path),
+                                        buffer, size, error.handler())
+        if error.code != 0:
+            raise FactoryException(error.what)
+        _initialized = True
+        return py_diagnostics + _from_c_str(buffer.value)
 
 
 def get_setting(key: str) -> Union[str, int, float, bool]:
@@ -2282,9 +2313,9 @@ def _initialize():
                 raise FactoryException(_err.what)
 
         # Where to look for pmd and pmk files
-        common_path = os.path.dirname(__file__)
-        factorylib.lib.psrd_initialize(_c_str(common_path),
-                                       _bytes(common_path),
+        module_path = os.path.dirname(__file__)
+        factorylib.lib.psrd_initialize(_c_str(module_path),
+                                       _bytes(module_path),
                                        _err.handler())
         if _err.code != 0:
             raise FactoryException(_err.what)

psr/factory/factory.pmd

@@ -981,6 +981,13 @@ DEFINE_MODEL MODL:Estima_Configuration
 	PARM	INTEGER		MarkovInitialWeek	
 END_MODEL
 
+DEFINE_CLASS PSRClusterMarkov
+	PARM	STRING		Name @id
+	
+	VECTOR	REFERENCE	HydroStations	PSRGaugingStation
+	VECTOR  REAL		HydroStationWeights
+END_CLASS
+
 //----------------------------------------------------------------------
 // Start of Factory runtime models
 //----------------------------------------------------------------------
@@ -4447,6 +4454,8 @@ DEFINE_MODEL MODL:SDDP_V10.2_Termica
         PARM INTEGER MaxStartUps
         PARM INTEGER MaxShutDowns
         PARM REAL   ShutDownCost
+		PARM REAL    RampUpCost
+        PARM REAL    RampDownCost
 
 	MERGE_MODEL SDDP_MAINTENANCE_PER_STAGE
 	MERGE_MODEL SDDP_MAINTENANCE_PER_HOUR
@@ -6626,6 +6635,7 @@ DEFINE_MODEL MODL:ePSR_CasoOperacao
 	PARM INTEGER		Crn	
 	PARM INTEGER		Itr	
 	PARM INTEGER		Cnv
+	PARM INTEGER		TpPl
 	PARM REAL		PMn
 	PARM REAL		PVt
 	PARM STRING             EtFCF

psr/factory/factory.pmk

@@ -12230,25 +12230,27 @@ DEFINE_MASK CSVDATA SDDP_v14.0_opectr
 
 DEFINE_HEADER
 $version=1
-!Code,Name........,RampUp,RampDown,MinUptime,MinDowntime,MaxStartUps,MaxShutDowns,ShutdownCost,WarmStartUpCost,ColdStartUpCost,PartialCoolingTime,TotalCoolingTime,ConstantGen,MaxUpTime
+!Code,Name........,RampUp,RampDown,MinUptime,MinDowntime,MaxStartUps,MaxShutDowns,ShutdownCost,WarmStartUpCost,ColdStartUpCost,PartialCoolingTime,TotalCoolingTime,ConstantGen,MaxUpTime,RampUpCost,RampDownCost
 END_HEADER
 
 DEFINE_DATA
-Code		INTEGER,1
-Name		STRING,2
-RampUp		REAL,3 AUTOSET(model.parm("RampUp"))
-RampDown	REAL,4 AUTOSET(model.parm("RampDown"))
-MinUptime	REAL,5 AUTOSET(model.parm("MinUptime"))
-MinDowntime	REAL,6 AUTOSET(model.parm("MinDowntime"))
-MaxStartUps	INTEGER,7 AUTOSET(model.parm("MaxStartUps"))
-MaxShutDowns	INTEGER,8 AUTOSET(model.parm("MaxShutDowns"))
-ShutDownCost	REAL,9 AUTOSET(model.parm("ShutDownCost"))
+Code				INTEGER,1
+Name				STRING,2
+RampUp				REAL,3 AUTOSET(model.parm("RampUp"))
+RampDown			REAL,4 AUTOSET(model.parm("RampDown"))
+MinUptime			REAL,5 AUTOSET(model.parm("MinUptime"))
+MinDowntime			REAL,6 AUTOSET(model.parm("MinDowntime"))
+MaxStartUps			INTEGER,7 AUTOSET(model.parm("MaxStartUps"))
+MaxShutDowns		INTEGER,8 AUTOSET(model.parm("MaxShutDowns"))
+ShutDownCost		REAL,9 AUTOSET(model.parm("ShutDownCost"))
 StartUpWarmCost 	REAL,10 AUTOSET(model.parm("StartUpWarmCost"))
 StartUpColdCost 	REAL,11 AUTOSET(model.parm("StartUpColdCost"))
 PartialCoolingTime	REAL,12 AUTOSET(model.parm("PartialCoolingTime"))
 TotalCoolingTime	REAL,13 AUTOSET(model.parm("TotalCoolingTime"))
-ConstantGen	INTEGER,14 AUTOSET(model.parm("ConstantGen"))
-MaxUptime	REAL,15 AUTOSET(model.parm("MaxUptime"))
+ConstantGen			INTEGER,14 AUTOSET(model.parm("ConstantGen"))
+MaxUptime			REAL,15 AUTOSET(model.parm("MaxUptime"))
+RampUpCost			REAL,16 AUTOSET(model.parm("RampUpCost"))
+RampDownCost		REAL,17 AUTOSET(model.parm("RampDownCost"))
 
 END_DATA