juice-simphony 0.1.0rc1__tar.gz

juice_simphony-0.1.0rc1/LICENSE.md

@@ -0,0 +1 @@
+Text pending on the decision of the ESA licencing board.

juice_simphony-0.1.0rc1/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.1
+Name: juice-simphony
+Version: 0.1.0rc1
+Summary: JUICE Scenario Generator
+License: MIT
+Author: JUICE SOC Team
+Requires-Python: >=3.9,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: jinja2 (>=3.1.6,<4.0.0)
+Requires-Dist: python-dotenv (>=1.1.0,<2.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Requires-Dist: setuptools (>=80.3.1,<81.0.0)
+Description-Content-Type: text/markdown
+
+# Symphony Web
+
+
+## Getting started
+
+
+## Project requirements
+
+- Python 3.8
+- Git
+
+## Preparing the environment 
+
+- Clone web repository:
+    git clone https://juigitlab.esac.esa.int/core-system/uplink/phs/juice-simphony.git
+
+
+- Find in "data/simphony" path the cfg_config.json and edit it for setting valid paths.
+  Example:
+        
+```
+{
+  "inputs": {
+    "juice_conf": "$HOME/juice_conf"
+  },
+  "scenario_generator": {
+    "scenario_output_area_abs_path": "$HOME/JUICE_PREOPS/PLANNING"
+  },
+  "spice": {
+    "kernel_abs_path": "$HOME/juice/kernels",
+    "available_toolkits": [
+      {
+        "toolkit_version": "N0067"
+      }
+    ]
+  }
+}
+```
+
+
+
+
+## Run the script
+
+```
+juice-simphony
+```
+
+This uses a default configuration file located in the directory specified above data/simphony/config_scenario.json.
+
+```
+{
+  "scenario_id": "S008_01",
+  "shortDesc": "ORB17",
+  "main_target": "Jupiter",
+  "trajectory": "CREMA_5_1_150lb_23_1_a3",
+  "mnemonic": "S008_ORB17_S13P00",
+  "startTime": "2032-12-18T17:32:33",
+  "endTime": "2033-01-08T21:05:31",
+  "iniAbsolutePath": "SOFTWARE/MAPPS",
+  "descriptions": {
+    "scenario_id": "number of the science scenario as per SOCs reference (scenario_number plus version index); expected format: 1 letter + 3 digits + _ + 2 digits (e.g., 'S008_01')",
+    "main_target": "object of interest (not used)",
+    "labelPrefix": "string (not used)",
+    "code": "sequential number of the output scenario",
+    "version": "version of the output scenario",
+    "trajectory": "trajectory identifier, to be used together with mnemonic; not needed if segment_id is provided",
+    "mnemonic": "mnemonic of the trajectory; to be used together with trajectory; not needed if segment_id is provided",
+    "segment_id": "segmentation identified; see https://juicesoc.esac.esa.int/rest_api/plan/; not needed if both trajectory and mnemonic are provided",
+    "shortDesc": "string for the output folder",
+    "startTime": "scenario start time; timestamp in ISO 8601 format YYYY-MM-DDTHH:MM:SS",
+    "endTime": "scenario end time; timestamp in ISO 8601 format YYYY-MM-DDTHH:MM:SS",
+    "iniAbsolutePath": "string (not used)"
+  }
+}
+```
+These are the current input parameters, some of them might be updated in the future. 
+
+For a different input, the script is aimed at be run using an input configuration file from the command like, called as
+```
+juice-simphony --config yourpath/config_scenario.json 
+```
+The segmentation can be selected either with both "trajectory" and "mnemonic", or using "segment_id". In this case, the input would be
+```
+{
+  "scenario_id": "S008_01",
+  "shortDesc": "ORB17",
+  "main_target": "Jupiter",
+  "segment_id": 409,  
+  "startTime": "2032-12-18T17:32:33",
+  "endTime": "2033-01-08T21:05:31",
+  "iniAbsolutePath": "SOFTWARE/MAPPS"
+} 
+```
+If "segment_id" is provided (used to define the trajectory as an SHT code), the parameters "trajectory" and "mnemonic" are ignored. For the Plan list, please check: https://juicesoc.esac.esa.int/rest_api/plan/
+
+To generate the MAPPS configuration, the parameter --mapps needs to be added to the command line, this is
+```
+juice-simphony --mapps 
+
+or 
+
+juice-simphony --config yourpath/config_scenario.json  --mapps
+```
+
+The output is a zip file in the output folder provided above in the configuration. 
+

juice_simphony-0.1.0rc1/README.md

@@ -0,0 +1,106 @@
+# Symphony Web
+
+
+## Getting started
+
+
+## Project requirements
+
+- Python 3.8
+- Git
+
+## Preparing the environment 
+
+- Clone web repository:
+    git clone https://juigitlab.esac.esa.int/core-system/uplink/phs/juice-simphony.git
+
+
+- Find in "data/simphony" path the cfg_config.json and edit it for setting valid paths.
+  Example:
+        
+```
+{
+  "inputs": {
+    "juice_conf": "$HOME/juice_conf"
+  },
+  "scenario_generator": {
+    "scenario_output_area_abs_path": "$HOME/JUICE_PREOPS/PLANNING"
+  },
+  "spice": {
+    "kernel_abs_path": "$HOME/juice/kernels",
+    "available_toolkits": [
+      {
+        "toolkit_version": "N0067"
+      }
+    ]
+  }
+}
+```
+
+
+
+
+## Run the script
+
+```
+juice-simphony
+```
+
+This uses a default configuration file located in the directory specified above data/simphony/config_scenario.json.
+
+```
+{
+  "scenario_id": "S008_01",
+  "shortDesc": "ORB17",
+  "main_target": "Jupiter",
+  "trajectory": "CREMA_5_1_150lb_23_1_a3",
+  "mnemonic": "S008_ORB17_S13P00",
+  "startTime": "2032-12-18T17:32:33",
+  "endTime": "2033-01-08T21:05:31",
+  "iniAbsolutePath": "SOFTWARE/MAPPS",
+  "descriptions": {
+    "scenario_id": "number of the science scenario as per SOCs reference (scenario_number plus version index); expected format: 1 letter + 3 digits + _ + 2 digits (e.g., 'S008_01')",
+    "main_target": "object of interest (not used)",
+    "labelPrefix": "string (not used)",
+    "code": "sequential number of the output scenario",
+    "version": "version of the output scenario",
+    "trajectory": "trajectory identifier, to be used together with mnemonic; not needed if segment_id is provided",
+    "mnemonic": "mnemonic of the trajectory; to be used together with trajectory; not needed if segment_id is provided",
+    "segment_id": "segmentation identified; see https://juicesoc.esac.esa.int/rest_api/plan/; not needed if both trajectory and mnemonic are provided",
+    "shortDesc": "string for the output folder",
+    "startTime": "scenario start time; timestamp in ISO 8601 format YYYY-MM-DDTHH:MM:SS",
+    "endTime": "scenario end time; timestamp in ISO 8601 format YYYY-MM-DDTHH:MM:SS",
+    "iniAbsolutePath": "string (not used)"
+  }
+}
+```
+These are the current input parameters, some of them might be updated in the future. 
+
+For a different input, the script is aimed at be run using an input configuration file from the command like, called as
+```
+juice-simphony --config yourpath/config_scenario.json 
+```
+The segmentation can be selected either with both "trajectory" and "mnemonic", or using "segment_id". In this case, the input would be
+```
+{
+  "scenario_id": "S008_01",
+  "shortDesc": "ORB17",
+  "main_target": "Jupiter",
+  "segment_id": 409,  
+  "startTime": "2032-12-18T17:32:33",
+  "endTime": "2033-01-08T21:05:31",
+  "iniAbsolutePath": "SOFTWARE/MAPPS"
+} 
+```
+If "segment_id" is provided (used to define the trajectory as an SHT code), the parameters "trajectory" and "mnemonic" are ignored. For the Plan list, please check: https://juicesoc.esac.esa.int/rest_api/plan/
+
+To generate the MAPPS configuration, the parameter --mapps needs to be added to the command line, this is
+```
+juice-simphony --mapps 
+
+or 
+
+juice-simphony --config yourpath/config_scenario.json  --mapps
+```
+
+The output is a zip file in the output folder provided above in the configuration. 

juice_simphony-0.1.0rc1/pyproject.toml

@@ -0,0 +1,27 @@
+[tool.poetry]
+name = "juice-simphony"
+#version = "0.1.0"
+version = "0.1.0-rc.1"  # RC version
+description = "JUICE Scenario Generator"
+authors = ["JUICE SOC Team"]
+license = "MIT"
+readme = "README.md"
+packages = [{ include = "juice_simphony", from = "src" }]
+
+[tool.poetry.dependencies]
+python = "^3.9"
+
+python-dotenv = "^1.1.0"
+jinja2 = "^3.1.6"
+setuptools = "^80.3.1"
+requests = "^2.32.3"
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.0.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.scripts]
+juice-simphony = "juice_simphony.cli:run"
+

juice_simphony-0.1.0rc1/src/juice_simphony/CompositionEngine/Scenario/attitude/attitude.py

@@ -0,0 +1,32 @@
+import juice_simphony.CompositionEngine.Scenario.common.utils as utils
+from juice_simphony.CompositionEngine.Scenario.definitions.toplevelObsDef import toplevelObsDef
+from juice_simphony.CompositionEngine.SegmentationImporter.SegmentationImporter import segmentationTimeline
+from juice_simphony.CompositionEngine.Scenario.attitude import xml_attitude as xml_att
+
+
+import os
+
+class attitude:
+
+    def __init__(self, segmentationTimelineInst, root_path, parameters=0):
+        self.root_path = root_path
+        self.segTimeline = segmentationTimelineInst
+        self.parameters = parameters
+        self.mainFolderPath = ""
+        self.structure = {}
+
+    def build(self):
+        self.createMainFolder('POINTING')
+        self.structure["path"]            = self.mainFolderPath;
+        self.structure["xmlAttitudeFile"] = self.addRootContent()
+        return self.structure
+
+    def createMainFolder(self, folderName):
+        self.mainFolderPath = utils.createFolder(self.root_path, folderName)
+
+    def addRootContent(self):
+        xml_seg_attitude = self.segTimeline.getXmlAttitude()
+        if xml_seg_attitude["valid"]:
+          xml_att_file = xml_att.xml_attitude(self.mainFolderPath, xml_seg_attitude["xml_tree"], self.parameters)
+          return xml_att_file.genFile()
+        return ""

juice_simphony-0.1.0rc1/src/juice_simphony/CompositionEngine/Scenario/attitude/xml_attitude.py

@@ -0,0 +1,147 @@
+from jinja2 import Template
+import os
+from datetime import datetime
+from xml.etree import ElementTree as et
+import xml.etree.cElementTree as etree
+from xml.dom import minidom
+from copy import deepcopy
+
+from juice_simphony.CompositionEngine.Scenario.common.fileHandleEps1 import fileHandleEps1
+from juice_simphony.CompositionEngine.Scenario.common.fileName import fileName
+from juice_simphony.CompositionEngine.Scenario.common.fileHandleXML import fileHandleXML
+
+class xml_attitude(fileHandleXML):
+
+    def __init__(self, path, xml_att_struct, params = 0):
+        self.params = {}
+        if params!=0: 
+            self.params.update(params)
+        self.path       = path
+        self.rootPath   = path
+        self.xml_att_struct = xml_att_struct
+        self.params["prefix"]  = "PTR"
+        self.params["type"]    = "SOC"
+        self.params["desc"]    = ""
+        self.params["version"] = "SXXPYY"
+        self.params["ext"]     = "ptx"
+        self.fileName  = ""
+        self.template  = 0
+        self.startTime = self.params["startTime"]
+        self.endTime   = self.params["endTime"]
+        self.time_format = "%Y-%m-%dT%H:%M:%S"
+        fileName.__init__(self, self.params)
+
+    def indent(self, elem, level=0):
+        i = "\n" + level*"  "
+        j = "\n" + (level-1)*"  "
+        if len(elem):
+            if not elem.text or not elem.text.strip():
+                elem.text = i + "  "
+            if not elem.tail or not elem.tail.strip():
+                elem.tail = i
+            for subelem in elem:
+                self.indent(subelem, level+1)
+            if not elem.tail or not elem.tail.strip():
+                elem.tail = j
+        else:
+            if level and (not elem.tail or not elem.tail.strip()):
+                elem.tail = j
+        return elem    
+
+    def writeTimelineHeader(self):
+        self.writeHeader(self.params["scenarioID"], "JUICE SEGMENTATION ATTITUDE")
+        #comment = etree.Comment(' === Some Comment === ')
+        #root.insert(1, comment)  # 1 is the index where comment is inserted
+        self.insertEmptyLine()
+
+    def write_xml_body(self):
+        #print (etree.tostring(self.xml_filtered_att, encoding='utf8', method='xml'))
+        #self.indent(self.xml_filtered_att)
+        xmlstr = minidom.parseString(etree.tostring(self.xml_filtered_att,encoding="unicode")).toprettyxml(indent = "   ")
+        line_list = [s for s in xmlstr.splitlines() if s.strip("\r\n").strip()]
+        xmlstr = os.linesep.join(line_list)
+        # COMMENTED by PE
+        #print(xmlstr)
+        self.fileHdl.write(xmlstr)
+#       et.indent(self.xml_filtered_att, space='    ', level=0)
+#       self.fileHdl.write(et.tostring(self.xml_filtered_att,encoding="unicode"))
+
+    def writeContent(self):
+        self.writeTimelineHeader()
+        self.xml_filtered_att = self.filterPtr(self.xml_att_struct, self.startTime, self.endTime)
+        self.write_xml_body()
+
+    def filterPtr(self, xml_struct_att, start_time, end_time, cut_block = True):
+        start_time_dt = datetime.strptime(start_time, self.time_format)
+        end_time_dt   = datetime.strptime(end_time,   self.time_format)
+
+        # Get timeline node
+        timeline = next(xml_struct_att.iter("timeline"))
+        xml_block_list = list(xml_struct_att.iter("block"))
+        xml_block_list_out = []
+        #xml_block_list_len = len(xml_block_list)
+        num_of_filtered_blocks = 0
+        for index,xml_block in enumerate(xml_block_list):
+            if (xml_block.attrib["ref"] == "SLEW"): continue
+            # xml_seg = next(xml_block.iter("segmentation"), None)
+            # if not xml_seg == None:
+            xml_seg_start_time_dt = datetime.strptime(xml_block.find('startTime').text.strip(), self.time_format)
+            xml_seg_end_time_dt   = datetime.strptime(xml_block.find('endTime').text.strip(),   self.time_format)
+            intersect, cutted_block, xml_cut_start_time_dt, xml_cut_end_time_dt = self.intersectTimeRange(start_time_dt, end_time_dt, xml_seg_start_time_dt, xml_seg_end_time_dt, cut_block)
+            if intersect:
+                if num_of_filtered_blocks >= 1:
+                    if xml_block_list[index-1].attrib["ref"] == "SLEW":
+                        xml_block_list_out.append(xml_block_list[index-1])
+                num_of_filtered_blocks = num_of_filtered_blocks + 1
+                if cutted_block:
+                    xml_block_start_time = next(xml_block.iter("startTime"), None)
+                    if not xml_block_start_time == None: 
+                        xml_block_start_time.text  = datetime.strftime(xml_cut_start_time_dt, "%Y-%m-%dT%H:%M:%S")
+                    xml_block_end_time = next(xml_block.iter("endTime"), None)
+                    if not xml_block_end_time == None: 
+                        xml_block_end_time.text = datetime.strftime(xml_cut_end_time_dt, "%Y-%m-%dT%H:%M:%S")
+                xml_block_list_out.append(xml_block)
+                last_block_end_time = xml_cut_end_time_dt
+        last_block = xml_block_list_out[-1]
+        xml_block_end_time = next(last_block.iter("endTime"), None)
+        if not xml_block_end_time == None: 
+           xml_block_end_time.text = datetime.strftime(last_block_end_time, "%Y-%m-%dT%H:%M:%S")
+        else:
+            end_time_el = et.Element("endTime")
+            end_time_el.text = datetime.strftime(last_block_end_time, "%Y-%m-%dT%H:%M:%S")
+            last_block.append(end_time_el)
+        timeline.clear()
+        timeline.attrib["frame"] = "SC";
+        timeline.extend(xml_block_list_out)
+
+        return xml_struct_att
+
+    def intersectTimeRange(self, startTime, endTime, xml_seg_start_time, xml_seg_end_time, cut_block = True):
+        cutted_block = False
+        if endTime <= xml_seg_start_time: # st et xml_st xml_et
+            return (False, cutted_block, xml_seg_start_time, xml_seg_end_time)
+        else: 
+            if xml_seg_end_time <= startTime: # xml_st xml_et st et 
+              return (False, cutted_block, xml_seg_start_time, xml_seg_end_time)
+            else: 
+                if cut_block:
+                   if endTime < xml_seg_end_time:  # xml_st et xml_et
+                      # Cut block end time
+                      xml_seg_end_time = endTime
+                      cutted_block = True
+                   if startTime > xml_seg_start_time:  # xml_st st xml_et
+                      # Cut block start time
+                      xml_seg_start_time = startTime
+                      cutted_block = True
+                return (True, cutted_block, xml_seg_start_time, xml_seg_end_time)
+
+if __name__ == "__main__":
+    xml_doc = et.parse(R"Z:\VALIDATION\simphony\pcm\phs_pcm_test_004\input\TMP\CREMA_5_0.xml")
+    root = xml_doc.getroot()
+
+    params = {}
+    params["scenarioID"] = "SJS0003C30A"
+    params["startTime"]  = "2032-09-01T01:00:00"
+    params["endTime"]    = "2032-09-28T08:00:00"
+    #xml_att_file = xml_attitude(path="Z:\VALIDATION\simphony\pcm\phs_pcm_test_001\scenario_generator\output", xml_att_struct=xml_doc.getroot(), params=params)
+    #xml_att_file.genFile()

juice_simphony-0.1.0rc1/src/juice_simphony/CompositionEngine/Scenario/common/fileHandle.py

@@ -0,0 +1,59 @@
+import configparser
+from jinja2 import Template
+import os
+from juice_simphony.CompositionEngine.Scenario.common.fileName import fileName
+
+class fileHandle(fileName):
+
+    def __init__(self, path, params=0):
+        if params!= 0: self.params.update(params)
+        self.path = path
+        self.fileName = ""
+        fileName.__init__(self)
+
+    def genFile(self):
+        
+        # Generate file name
+        self.fileName = self.genBaseFileName() + "." + self.params["ext"]
+        destFilePath = os.path.join(self.path, self.fileName)
+        #destFilePath = self.path
+
+        # Open File
+        self.fileHdl  = open(destFilePath, "w")
+
+        # Write Content
+        self.writeContent()
+
+        # Close File
+        self.fileHdl.close()
+
+        return destFilePath
+
+    def loadRefFile(self, filePath):
+        with open(filePath) as tplFile:
+            self.template = Template(tplFile.read())
+
+    def writeContent(self):
+         a=1
+
+    def writeHeader(self, title, shortDesc, description=""):
+        self.fileHdl.write(             "#----------------------------------------------------------------------------------------------------#\n")
+        self.fileHdl.write(             "#                                                                                                    #\n")
+        self.fileHdl.write('#{:^100s}#\n'.format(title))
+        self.fileHdl.write('#{:^100s}#\n'.format(shortDesc))
+        self.fileHdl.write(             "#                                                                                                    #\n")
+        self.fileHdl.write(             "#----------------------------------------------------------------------------------------------------#\n")
+        
+        if description != "":
+           self.fileHdl.write ("\n")
+           
+           self.fileHdl.write          ("#----------------------------------------------------------------------------------------------------#\n")
+           self.fileHdl.write          ("# DESCRIPTION:\n")
+           self.fileHdl.write          (description + "\n")
+           self.fileHdl.write          ("#----------------------------------------------------------------------------------------------------#\n")
+        
+    def insertEmptyLine(self):
+        self.fileHdl.write("\n")
+
+    def insertComment(self,text):
+        self.fileHdl.write("# " + text + "\n")

juice_simphony-0.1.0rc1/src/juice_simphony/CompositionEngine/Scenario/common/fileHandleEps.py

@@ -0,0 +1,33 @@
+
+import os
+from juice_simphony.CompositionEngine.Scenario.common.fileHandle import fileHandle
+
+class fileHandleEps(fileHandle):
+    def __init__(self, path, params=0):
+        if params!= 0: self.params.update(params)
+        self.path = path
+        fileHandle.__init__(self, path)
+
+    def insertVersion (self, version = 1):
+        self.fileHdl.write("# Timeline version" + "\n")
+        self.fileHdl.write("Version: 1" + "\n")
+
+    def insertTimeWindow (self, startTime, endTime):
+        self.fileHdl.write("# Time Window" + "\n")
+        self.fileHdl.write("Start_time: " + startTime + "\n")
+        self.fileHdl.write("End_time:   " + endTime   + "\n")
+
+    def insertInclude(self,params):
+        fileNameRel = os.path.relpath(params["filePath"], self.rootPath).replace("\\","/")
+        if "fileDescription" in params:
+            self.insertEmptyLine()
+            self.fileHdl.write("# " + params["fileDescription"] + "\n")
+        self.fileHdl.write("Include: " + fileNameRel + "\n")
+        
+    def insertIncludeFile(self,params):
+        fileNameRel = os.path.relpath(params["filePath"], self.rootPath).replace("\\","/")
+        if "fileDescription" in params:
+            self.insertEmptyLine()
+            self.fileHdl.write("# " + params["fileDescription"] + "\n")
+        self.fileHdl.write("Include_file: " + "\"" + fileNameRel + "\"" + "\n")
+        

juice_simphony-0.1.0rc1/src/juice_simphony/CompositionEngine/Scenario/common/fileHandleEps1.py

@@ -0,0 +1,30 @@
+import os
+from .fileHandle import fileHandle
+
+class fileHandleEps1(fileHandle):
+    def __init__(self):
+        fileHandle.__init__(self,self.path)
+
+    def insertVersion (self, version = 1):
+        self.fileHdl.write("# Timeline version" + "\n")
+        self.fileHdl.write("Version: 1" + "\n")
+
+    def insertTimeWindow (self, startTime, endTime):
+        self.fileHdl.write("# Time Window" + "\n")
+        self.fileHdl.write("Start_time: " + startTime + "\n")
+        self.fileHdl.write("End_time:   " + endTime   + "\n")
+
+    def insertInclude(self,params):
+        fileNameRel = os.path.relpath(params["filePath"], self.rootPath).replace("\\","/")
+        if "fileDescription" in params:
+            self.insertEmptyLine()
+            self.fileHdl.write("# " + params["fileDescription"] + "\n")
+        self.fileHdl.write("Include: " + fileNameRel + "\n")
+        
+    def insertIncludeFile(self,params):
+        fileNameRel = os.path.relpath(params["filePath"], self.rootPath).replace("\\","/")
+        if "fileDescription" in params:
+            self.insertEmptyLine()
+            self.fileHdl.write("# " + params["fileDescription"] + "\n")
+        self.fileHdl.write("Include_file: " + "\"" + fileNameRel + "\"" + "\n")
+        

juice_simphony-0.1.0rc1/src/juice_simphony/CompositionEngine/Scenario/common/fileHandleTml.py

@@ -0,0 +1,77 @@
+import os
+from juice_simphony.CompositionEngine.Scenario.common.fileHandleEps import fileHandleEps
+
+class fileHandleTml(fileHandleEps):
+    def __init__(self, path, params=0):
+        if params!= 0: self.params.update(params)
+        self.path = path
+        self.fileName = ""
+        fileHandleEps.__init__(self, self.path, self.params)
+
+    def insertInitPM (self, param, par_pad, value, value_pad, comment):
+        self.fileHdl.write(f'Init_PM: { param : <{par_pad}} {value:<{value_pad}.2f} # {comment}\n')
+
+    def insertInitMS (self, exp, exp_pad, module, module_pad, mode, mode_pad, comment):
+        self.fileHdl.write(f'Init_MS: { exp : <{exp_pad}}{ module : <{module_pad}}{ mode : <{mode_pad}} # {comment}\n')
+
+    def insertRequestEntry(self,date, exp, mode, action, par_label, par_value, comment):
+        comment_lines = comment.splitlines()
+        for comment_line in comment_lines:
+            if comment_line != "": self.fileHdl.write(f'# {comment_line}\n')
+        if 'Z' in date:
+           self.fileHdl.write(f'{date} {exp} {mode} {action} ({par_label} = {par_value:12.7f})\n')
+        else:
+           self.fileHdl.write(f'{date}Z {exp} {mode} {action} ({par_label} = {par_value:12.7f})\n')
+
+    def insertLine(self,text):
+        self.fileHdl.write(text + "\n")
+''''
+# Spacecrat platform initialization
+# ------------------------------------
+
+Init_PM: BATTERY_DOD 0.0    # Battery DoD
+Init_MS: JUICE DST_X_R NOM  # Antena Receiver always ON
+Init_MS: JUICE PLATFORM ON  # Platform ON to enable platform power consumption
+
+
+# Set platform profile
+# ---------------------
+2032-01-09T16:44:04Z JUICE  *  SET_POWER (VALUE=572.9135779720983)
+'''''
+if __name__ == '__main__':
+
+    param       = "BATTERY_DOD"
+    par_pad     = 8
+    value       = 0.0
+    value_pad  = 8
+    comment     = "Antena Receiver always ON"
+    print(f'Init_PM: { param : <{par_pad}} {value:<{value_pad}.2f} # {comment}')
+
+    exp         = "JUICE"
+    exp_pad     = 8
+    module      = "DST_X_R"
+    module_pad  = 9
+    mode        = "NOM"
+    mode_pad    = 5
+    comment     = "Antena Receiver always ON"
+    print(f'Init_PM: { exp : <{exp_pad}} { module : <{module_pad}} { mode : <{mode_pad}} # {comment}')
+
+    exp         = "JUICE"
+    exp_pad     = 8
+    module      = "PLATFORM"
+    module_pad  = 9
+    mode        = "ON"
+    mode_pad    = 5
+    comment     = "Platform ON to enable platform power consumption"
+    print(f'Init_PM: { exp : <{exp_pad}} { module : <{module_pad}} { mode : <{mode_pad}} # {comment}')
+
+    date      = "2032-01-09T16:44:04Z"
+    exp       = "JUICE"
+    mode      = " * "
+    action    = "SET_POWER"
+    par_label = "VALUE"
+    par_value = 572.9135779720983
+    comment     = "This is coming from R[001]"
+    print(f'Comment: {comment}')
+    # 2032-01-09T16:44:04Z JUICE  *  SET_POWER (VALUE=572.9135779720983)
+    print(f'{date} {exp} {mode} {action} ({par_label} = {par_value:18.13f})')