Generate TT and catlog parameters for plot

Benjamin Renard
1 parent db7ea505
Showing 8 changed files with 537 additions and 3 deletions Show diff stats
src/InputOutput/IHMImpl/Params/PlotImpl/IHMInputOutputParamsPlotClass.php
src/InputOutput/IHMImpl/Tools/IHMParamManagerClass.php
src/InputOutput/IHMImpl/Tools/IHMTTCatLoaderClass.php
src/Request/ParamsRequestImpl/Nodes/Infos/InfoParamNodeClass.php
src/Request/ParamsRequestImpl/Nodes/Params/ParamGetConstantNodeClass.php
src/Request/ParamsRequestImpl/Nodes/Params/ParamGetConstantParamNodeClass.php
src/Request/ParamsRequestImpl/Nodes/Params/ParamNodeClass.php
src/Request/ParamsRequestImpl/ParamsRequestDataClass.php
@@ -662,8 +662,15 @@ class IHMInputOutputParamsPlotClass extends IHMInputOutputParamsAbstractClass
 		$drawingEltIndex = 0;
 		foreach ($paramsData as $paramData)
 		{
+			$isTTCat = ($paramData->{'param-type'} == 'ttcat');
+
 			//Param
-			$paramInfo = $this->paramManager->addExistingParam($paramData->{'paramid'}, $this->paramsData, isset($paramData->{'template_args'}) ? $paramData->{'template_args'} : NULL);
+			if (!$isTTCat) {
+				$paramInfo = $this->paramManager->addExistingParam($paramData->{'paramid'}, $this->paramsData, isset($paramData->{'template_args'}) ? $paramData->{'template_args'} : NULL);
+			}
+			else {
+				$paramInfo = $this->paramManager->addTTCatParam($paramData->{'paramid'}, $this->paramsData);
+			}
  
 			$paramInfo['indexes'] = array();
  
@@ -11,6 +11,7 @@ class IHMParamManagerClass
 	protected $expressionParser = null;
 	protected $templateParamsManager = null;
 	protected $paramImpexMgr     = null;
+	protected $ttCatMgr = null;
  
 	/*
 	 * @brief Constructor
@@ -68,6 +69,79 @@ class IHMParamManagerClass
 	}
  
 	/*
+	 *  @brief Add a TT or catalog parameter
+	 */
+	public function addTTCatParam($paramId, $paramsData)
+	{
+		if (!isset($this->ttCatMgr)) {
+			$this->ttCatMgr = new IHMTTCatLoaderClass();
+		}
+		$info = $this->ttCatMgr->getTTCatInfoFromId($paramId);
+
+		if (!$info["success"]) {
+			throw new Exception($info["message"]);
+		}
+
+		$status = array();
+		$units = "";
+		$ytitle = "";
+		$flag = "";
+
+		if ($info["info"]["isCatalog"]) {
+			$parameters = $this->ttCatMgr->getCatalogParameters($paramId);
+			if (!$parameters["success"] || empty($parameters["parameters"])) {
+				throw new Exception("Error to extract first parameter of ".$paramId);
+			}
+			//For the moment, use the first parameter
+			$parameter = $parameters["parameters"][0];
+			$units     = $parameter["units"];
+			$ytitle    = !empty($parameter["name"]) ? $parameter["name"] : $parameter["id"];
+			$flag      = $parameter["id"];
+			$description = $parameter["description"];
+			$desc_parts = array();
+			foreach (explode("-",$description) as $def) {
+				$def = trim($def);
+				$p = strpos($def, ":");
+				if ($p === FALSE) {
+					continue;
+				}
+				$val = substr($def, 0, $p);
+				$val = trim($val);
+				$name = substr($def, $p+1);
+				$name = trim($name);
+				$color = "";
+				$p = strpos($name, "[");
+				if ($p !== FALSE) {
+					$color = substr($name, $p);
+					$color = trim($color);
+					$name = substr($name, 0, $p);
+					$name = trim($name);
+				}
+				$status[] = array(
+					"min" => floatval($val),
+					"max" => floatval($val),
+					"name" => $name,
+					"color" => $color,
+				);
+			}
+		}
+		else {
+			$status = array(
+				array(
+					"min" => 1,
+					"max" => 1,
+					"name" => "Inside",
+					"color" => "[255,0,0]",
+				)
+			);
+			$ytitle = $info["info"]["name"];
+		}
+
+		$paramsData->addTTCatParamToCreate($paramId, $info["info"]["path"], $info["info"]["isShared"], filemtime($info["info"]["path"]), $units, $ytitle, $status, $flag);
+		return array("id" => $paramId, "indexes" => array(), "calib_infos" => array());
+	} 
+
+	/*
 	 * @brief Detect if it's a derived parameter
 	*/
 	private function isDerivedParam($param)
@@ -0,0 +1,235 @@
+<?php
+
+/**
+ * @class IHMTTCatLoaderClass
+ * @brief Loader for IHM TimeTables and Catalogs properties
+ * @details
+ */
+class IHMTTCatLoaderClass
+{
+	protected $ttCatList = null;
+
+	private static $userTTCatFile               = 'Tt.xml';
+	
+	private static $mgrUserTTListNode           = 'timetabList';
+	private static $mgrUserTTEltNode            = 'timetab';
+
+	private static $mgrUserCatListNode          = 'catalogList';
+	private static $mgrUserCatEltNode           = 'catalog';
+
+	private static $mgrUserTTCatEltIdAtt        = 'xml:id';
+	private static $mgrUserTTCatEltNameAtt      = 'name';
+	private static $mgrUserTTCatEltNbIntAtt     = 'intervals';
+
+	private static $mgrUserTTCatFolderNode      = 'folder';
+	private static $mgrUserTTCatFolderIdAtt     = 'xml:id';
+	private static $mgrUserTTCatFolderNameAtt   = 'name';
+
+	private static $mgrSharedTTListNode         = 'timeTableList';
+	private static $mgrSharedTTEltNode          = 'timeTable';
+
+	private static $mgrSharedCatListNode        = 'catalogList';
+	private static $mgrSharedCatEltNode         = 'catalog';
+
+	private static $mgrSharedTTCatEltIdAtt      = 'xml:id';
+	private static $mgrSharedTTCatEltNameAtt    = 'name';
+	private static $mgrSharedTTCatEltNbIntAtt   = 'nbIntervals';
+
+	private static $mgrSharedTTCatFolderNode    = 'folder';
+	private static $mgrSharedTTCatFolderIdAtt   = 'xml:id';
+	private static $mgrSharedTTCatFolderNameAtt = 'name';
+
+	/*
+	 * @brief Constructor
+	*/
+	function __construct()
+	{
+	}
+	
+	/*
+	 * @brief Get info about a TT or a catalog from id
+	 */
+	public function getTTCatInfoFromId($id)
+	{
+		if (!isset($this->ttCatList)) {
+			$this->ttCatList = $this->loadTTCatManagerFiles();
+		}
+		if (!array_key_exists($id, $this->ttCatList)) {
+			return array("success" => false, "message" => "Cannot retrieve TT or catalog");
+		}
+		return array("success" => true, "info" => $this->ttCatList[$id]);
+	}
+
+	/*
+	 * @brief Get parameters from id (empty for a TT)
+	 */
+	public function getCatalogParameters($id)
+	{
+		$info = $this->getTTCatInfoFromId($id);
+		if (!$info["success"]) {
+			return $info;
+		}
+
+		if (!$info["info"]["isCatalog"]) {
+			return array("success" => TRUE, "parameters" => array());
+		}
+
+		$dom = new DomDocument("1.0");
+                if (!$dom->load($info["info"]["path"])) {
+			return array("success" => FALSE, "message" => "Cannot open catalog ".$id);
+		}
+
+		$parametersNodes = $dom->getElementsByTagName("parameters");
+		if ($parametersNodes->length == 0) {
+			return array("success" => FALSE, "message" => "Cannot retrieve parameters node in catalog ".$id);
+		}
+
+		$parametersNode = $parametersNodes->item(0);
+
+		$parameterNodes = $parametersNode->getElementsByTagName("parameter");
+
+		$parameters = array();
+		foreach ($parameterNodes as $parameterNode) {
+			$parameters[] = array(
+				"id" => $parameterNode->getAttribute("id"),
+				"name" => $parameterNode->getAttribute("name"),
+				"size" => $parameterNode->getAttribute("size"),
+				"type" => $parameterNode->getAttribute("type"),
+				"unit" => $parameterNode->getAttribute("unit"),
+				"description" => $parameterNode->getAttribute("description"),
+				"ucd" => $parameterNode->getAttribute("ucd"),
+				"utype" => $parameterNode->getAttribute("utype"),
+			);
+		}
+
+		return array("success" => TRUE, "parameters" => $parameters);
+	}
+	
+
+	/*
+	 * @brief Load all TT and catalogs from manager files
+	 */
+	private function loadTTCatManagerFiles()
+	{
+		if (isset($this->ttCatList)) {
+			return $this->ttCatList;
+		}
+
+		return $this->loadUserTTCatManagerFile() + $this->loadSharedTTCatManagerFile();
+	}
+
+	/*
+	 * @brief Load user TT and cat manager file
+	 */
+	private function loadUserTTCatManagerFile()
+	{
+		//load xml file
+		$dom = new DomDocument("1.0");
+		if (!$dom->load(IHMConfigClass::getUserWSPath() . '/' . self::$userTTCatFile))
+			return array();
+
+		$ttCat = array();
+
+		//get TT
+		$listNodes = $dom->getElementsByTagName(self::$mgrUserTTListNode);
+		if ($listNodes->length > 0) {
+			$this->getEltRecursively($listNodes->item(0), FALSE, FALSE, array(), $ttCat);
+		}
+
+		//get catalogs
+		$listNodes = $dom->getElementsByTagName(self::$mgrUserCatListNode);
+		if ($listNodes->length > 0) {
+			$this->getEltRecursively($listNodes->item(0), FALSE, TRUE, array(), $ttCat);
+		}
+
+		return $ttCat;
+	}
+	
+	/*
+	 * @brief Load shared objects manager file
+	 */
+	private function loadSharedTTCatManagerFile()
+	{
+		//load xml file
+		$dom = new DomDocument("1.0");
+		if (!$dom->load(IHMConfigClass::getSharedTreeFilePath()))
+			return array();
+
+		$ttCat = array();
+
+		//get TT
+		$listNodes = $dom->getElementsByTagName(self::$mgrSharedTTListNode);
+		if ($listNodes->length > 0) {
+			$this->getEltRecursively($listNodes->item(0), TRUE, FALSE, array(), $ttCat);
+		}
+
+		//get catalogs
+		$listNodes = $dom->getElementsByTagName(self::$mgrSharedCatListNode);
+		if ($listNodes->length > 0) {
+			$this->getEltRecursively($listNodes->item(0), TRUE, TRUE, array(), $ttCat);
+		}
+
+		return $ttCat;
+	}
+
+	private function getEltRecursively($baseNode, $isShared, $isCatalog, $folders, &$elts) {
+		if ($isShared) {
+			$basePath = IHMConfigClass::getSharedPath();
+			if ($isCatalog) {
+				$eltNode = self::$mgrSharedCatEltNode;
+				$basePath .= "/CAT";
+			}
+			else {
+				$eltNode = self::$mgrSharedTTEltNode;
+				$basePath .= "/TT";
+			}
+			$eltIdAtt      = self::$mgrSharedTTCatEltIdAtt;
+			$eltNameAtt    = self::$mgrSharedTTCatEltNameAtt;
+			$eltNbIntAtt   = self::$mgrSharedTTCatEltNbIntAtt;
+			$folderNode    = self::$mgrSharedTTCatFolderNode;
+			$folderIdAtt   = self::$mgrSharedTTCatFolderIdAtt;
+			$folderNameAtt = self::$mgrSharedTTCatFolderNameAtt;
+			if (!empty($folders)) {
+				$basePath .= "/".$folders[0]["name"]."/data";
+			}
+		}
+		else {
+			$basePath = IHMConfigClass::getUserTTPath();
+			if ($isCatalog) {
+				$eltNode = self::$mgrUserCatEltNode;
+			}
+			else {
+				$eltNode = self::$mgrUserTTEltNode;
+			}
+			$eltIdAtt      = self::$mgrUserTTCatEltIdAtt;
+			$eltNameAtt    = self::$mgrUserTTCatEltNameAtt;
+			$eltNbIntAtt   = self::$mgrUserTTCatEltNbIntAtt;
+			$folderNode    = self::$mgrUserTTCatFolderNode;
+			$folderIdAtt   = self::$mgrUserTTCatFolderIdAtt;
+			$folderNameAtt = self::$mgrUserTTCatFolderNameAtt;
+		}
+
+		$eltNodes = $baseNode->getElementsByTagName($eltNode);
+		foreach ($eltNodes as $node) {
+			$elts[$node->getAttribute($eltIdAtt)] = array(
+				"id" => $node->getAttribute($eltIdAtt),
+				"name" => $node->getAttribute($eltNameAtt),
+				"nbIntervals" => $node->getAttribute($eltNbIntAtt),
+				"folders" => $folders,
+				"path" => $basePath . "/" . $node->getAttribute($eltIdAtt). ".xml",
+				"isShared" => $isShared,
+				"isCatalog" => $isCatalog,
+			);
+		}
+
+		$folderNodes = $baseNode->getElementsByTagName($folderNode);
+		foreach ($folderNodes as $node) {
+			$crt_folders = $folders;
+			$crt_folders[] = array(
+				"id" => $node->getAttribute($folderIdAtt),
+				"name" => $node->getAttribute($folderNameAtt),
+			);
+			$this->getEltRecursively($node, $isShared, $isCatalog, $crt_folders, $elts);
+		}
+	}
+}
@@ -16,7 +16,12 @@ define (&quot;INFOPARAM_SICONV&quot;, &quot;si_conversion&quot;);
 define ("INFOPARAM_TABLE", "table");
 define ("INFOPARAM_FILLVAL", "fill_value");
 define ("INFOPARAM_UCD", "ucd");
-//define ("INFOPARAM_STATUSDEF", "status_def");
+define ("INFOPARAM_STATUSDEF", "status_def");
+define ("INFOPARAM_STATUS", "status");
+define ("INFOPARAM_STATUS_MINVAL", "minVal");
+define ("INFOPARAM_STATUS_MAXVAL", "maxVal");
+define ("INFOPARAM_STATUS_NAME", "name");
+define ("INFOPARAM_STATUS_COLOR", "color");
 define ("INFOPARAM_DATASETID", "dataset_id");
  
 /**
@@ -51,7 +56,7 @@ class InfoParamNodeClass extends NodeClass
 		$this->getChildInstanceByName(INFOPARAM_TABLE,true);
 		$this->getChildInstanceByName(INFOPARAM_FILLVAL,true);
 		$this->getChildInstanceByName(INFOPARAM_UCD,true);
-		//$this->getChildInstanceByName(INFOPARAM_STATUSDEF,true);
+		$this->getChildInstanceByName(INFOPARAM_STATUSDEF,true);
 		$this->getChildInstanceByName(INFOPARAM_DATASETID,true);
 	}
  
@@ -148,6 +153,28 @@ class InfoParamNodeClass extends NodeClass
 	{
 		return $this->getChildInstanceByName(INFOPARAM_TABLE, true);
 	}
+
+	public function getStatusDef()
+	{
+		return $this->getChildInstanceByName(INFOPARAM_STATUSDEF, true);
+	}
+
+	public function addStatus($min, $max, $name, $color = "")
+	{
+		$node = $this->getStatusDef();
+
+		$statusNode = new NodeClass(INFOPARAM_STATUS);
+		$statusNode->setAttribute(INFOPARAM_STATUS_MINVAL, $min);
+		$statusNode->setAttribute(INFOPARAM_STATUS_MAXVAL, $max);
+		$statusNode->setAttribute(INFOPARAM_STATUS_NAME, $name);
+		if (!empty($color)) {
+			$statusNode->setAttribute(INFOPARAM_STATUS_COLOR, $color);
+		}
+
+		$node->addChild($statusNode);
+
+		return $statusNode;
+	}
  
 	public function loadFromNode($xmlNode)
 	{
@@ -208,6 +235,17 @@ class InfoParamNodeClass extends NodeClass
 		$ucdXmlNode = $this->getXmlNodeChildByTagName($xmlNode, INFOPARAM_UCD);
 		if (isset($ucdXmlNode))
 			$this->setUCD($this->getXmlNodeValue($ucdXmlNode));
+
+		$statusDefXmlNode = $this->getXmlNodeChildByTagName($xmlNode, INFOPARAM_STATUSDEF);
+		if (isset($statusDefXmlNode)) {
+			foreach ($this->getXmlNodeChildren($statusDefXmlNode) as $statusNode) {
+				$minVal = $this->getXmlNodeAttribute($statusNode, INFOPARAM_STATUS_MINVAL);
+				$maxVal = $this->getXmlNodeAttribute($statusNode, INFOPARAM_STATUS_MAXVAL);
+				$name = $this->getXmlNodeAttribute($statusNode, INFOPARAM_STATUS_NAME);
+				$color = $this->getXmlNodeAttribute($statusNode, INFOPARAM_STATUS_COLOR);
+				$this->addStatus($minVal, $maxVal, $name, $color);
+			}
+		}
  
 		$datasetidXmlNode = $this->getXmlNodeChildByTagName($xmlNode, INFOPARAM_DATASETID);
 		if (isset($datasetidXmlNode))
@@ -0,0 +1,53 @@
+<?php
+
+require_once "ParamGetConstantParamNodeClass.php";
+
+define ("PARAMGETCONSTANT_VI", "constant");
+
+/**
+ * @class ParamGetConstantNodeClass
+ * @brief Definition of a constant getter for AMDA_Kernel
+ * @details
+*/
+class ParamGetConstantNodeClass extends NodeClass
+{
+	public function __construct()
+	{
+		parent::__construct(PARAMGETCONSTANT_VI);
+	}
+
+	public function getConstant($sampling = "60", $type = "int", $dim1 = "1", $dim2 = "1", $value = "1")
+	{
+		$nodes = $this->getChildrenByName(PARAMGETCONSTANTPARAM_NAME);
+	
+		foreach ($nodes as $node)
+			if (($node->getSampling() == $sampling) && ($node->getType() == $type) && ($node->getConstValue() == $value) &&
+				($node->getDim1() == $dim1) && ($node->getDim2() == $dim2))
+			return $node;
+		return NULL;
+	}
+	
+	public function addConstant($sampling = "60", $type = "int", $dim1 = "1", $dim2 = "1", $value = "1")
+	{
+		$constantNode = new ParamGetConstantParamNodeClass();
+		
+		$constantNode->setSampling($sampling);
+		$constantNode->setType($type);
+		$constantNode->setDim1($dim1);
+		$constantNode->setDim2($dim2);
+		$constantNode->setConstValue($value);
+
+		$this->addChild($constantNode);
+		
+		return $constantNode;
+	}
+	
+	public function loadFromNode($xmlNode)
+	{
+		foreach ($this->getXmlNodeChildrenByTagName($xmlNode, PARAMGETCONSTANTPARAM_NAME) as $constantXmlNode) {
+			$this->addConstant()->loadFromNode($constantXmlNode);
+		}
+	}
+}
+
+?>
@@ -0,0 +1,86 @@
+<?php
+
+define ("PARAMGETCONSTANTPARAM_NAME", "param");
+define ("PARAMGETCONSTANTPARAM_SAMPLING", "sampling");
+define ("PARAMGETCONSTANTPARAM_TYPE", "type");
+define ("PARAMGETCONSTANTPARAM_VALUE", "value");
+define ("PARAMGETCONSTANTPARAM_DIM1", "dim1");
+define ("PARAMGETCONSTANTPARAM_DIM2", "dim2");
+
+/**
+ * @class ParamGetConstantParamNodeClass
+ * @brief Definition of a constant parameter
+ * @details
+*/
+class ParamGetConstantParamNodeClass extends NodeClass
+{
+	public function __construct()
+	{
+		parent::__construct(PARAMGETCONSTANTPARAM_NAME);
+	}
+
+	public function getSampling()
+	{
+		return $this->getAttribute(PARAMGETCONSTANTPARAM_SAMPLING);
+	}
+
+	public function setSampling($sampling)
+	{
+		$this->setAttribute(PARAMGETCONSTANTPARAM_SAMPLING, $sampling);
+	}
+
+	public function getType()
+	{
+		return $this->getAttribute(PARAMGETCONSTANTPARAM_TYPE);
+	}
+
+	public function setType($type)
+	{	
+		$this->setAttribute(PARAMGETCONSTANTPARAM_TYPE, strtolower($type));
+	}
+
+	public function getConstValue()
+	{
+		return $this->getAttribute(PARAMGETCONSTANTPARAM_VALUE);
+	}
+
+	public function setConstValue($value)
+	{
+		$this->setAttribute(PARAMGETCONSTANTPARAM_VALUE, $value);
+	}
+
+	public function getDim1()
+	{
+		return $this->getAttribute(PARAMGETCONSTANTPARAM_DIM1);
+	}
+
+	public function setDim1($dim1)
+	{
+		$this->setAttribute(PARAMGETCONSTANTPARAM_DIM1, $dim1);
+	}
+
+	public function getDim2()
+	{
+		return $this->getAttribute(PARAMGETCONSTANTPARAM_DIM2);
+	}
+
+	public function setDim2($dim2)
+	{
+		$this->setAttribute(PARAMGETCONSTANTPARAM_DIM2, $dim2);
+	}
+	
+	public function loadFromNode($xmlNode)
+	{
+		$this->setSampling($this->getXmlNodeAttribute($xmlNode, PARAMGETCONSTANTPARAM_SAMPLING));
+
+		$this->setType($this->getXmlNodeAttribute($xmlNode, PARAMGETCONSTANTPARAM_TYPE));
+
+		$this->setConstValue($this->getXmlNodeAttribute($xmlNode, PARAMGETCONSTANTPARAM_VALUE));
+
+		$this->setDim1($this->getXmlNodeAttribute($xmlNode, PARAMGETCONSTANTPARAM_DIM1));
+
+		$this->setDim2($this->getXmlNodeAttribute($xmlNode, PARAMGETCONSTANTPARAM_DIM2));
+	}
+}
+
+?>
@@ -4,6 +4,7 @@ require_once &quot;ParamClbManualNodeClass.php&quot;;
 require_once "ParamGetAmdaParamNodeClass.php";
 require_once "ParamGetDDBaseNodeClass.php";
 require_once "ParamGetLocalBaseNodeClass.php";
+require_once "ParamGetConstantNodeClass.php";
 require_once dirname(__FILE__)."/../Infos/InfoParamNodeClass.php";
 require_once dirname(__FILE__)."/../Requests/RequestOutputPlotPanelNodeClass.php";
  
@@ -22,6 +23,7 @@ abstract class ParamGetTypeEnum
 	const AMDAPARAM   = "AmdaParam";
 	const DDBASE      = "DDBase";
 	const LOCALBASE   = "LocalBase";
+	const CONSTANT    = "Constant";
 }
  
 /**
@@ -89,6 +91,9 @@ class ParamNodeClass extends NodeClass
 			case ParamGetTypeEnum::LOCALBASE :
 				$paramGet = new ParamGetLocalBaseNodeClass();
 				break;
+			case ParamGetTypeEnum::CONSTANT :
+				$paramGet = new ParamGetConstantNodeClass();
+				break;
 			default :
 				throw new Exception('Param get node not implemented');
 		}
@@ -164,6 +169,9 @@ class ParamNodeClass extends NodeClass
 					case PARAMGETLOCALBASE_VI :
 						$this->addParamGet(ParamGetTypeEnum::LOCALBASE)->loadFromNode($paramGetDefXmlNode);
 						break;
+					case PARAMGETCONSTANT_VI :
+						$this->addParamGet(ParamGetTypeEnum::CONSTANT)->loadFromNode($paramGetDefXmlNode);
+						break;
 				}
 			}
 		}
@@ -169,6 +169,39 @@ class ParamsRequestDataClass extends ProcessRequestDataClass
  
 		$this->processParamsToCreate[$paramId] = array('param' => $newParam, 'dateModif' => $dateModif);
 	}
+
+	public function addTTCatParamToCreate($paramId, $ttCatFilePath, $isShared, $dateModif, $units, $ytitle, $status, $flag = "")
+	{
+		$newParam = new ParamNodeClass();
+		$newParam->setId($paramId);
+		if (!empty($units)) {
+			$newParam->getInfo()->setUnits($units);
+		}
+		if (!empty($ytitle)) {
+			$newParam->getInfo()->setShortName($ytitle);
+		}
+		else {
+			$newParam->getInfo()->setShortName($paramId);
+		}
+		if (!empty($status)) {
+			foreach ($status as $def) {
+				$newParam->getInfo()->addStatus($def["min"], $def["max"], $def["name"], $def["color"]);
+			}
+		}
+		$constantGetNode = $newParam->addParamGet(ParamGetTypeEnum::CONSTANT);
+		$constantParamNode = $constantGetNode->addConstant();
+		$constantParamNode->setSampling(1);
+		$process = "#ttcat_to_param(\$constant_1_".$constantParamNode->getType()."_";
+		$process .= $constantParamNode->getConstValue()."_".$constantParamNode->getDim1()."_".$constantParamNode->getDim2().";".$ttCatFilePath;
+		if (!empty($flag)) {
+			$process .= ";".$flag;
+		}
+		$process .= ")";
+		$newParam->setProcess($process, "Transform Time Table or Catalog to a parameter", !$isShared);
+		$newParam->setOutput();
+
+		$this->processParamsToCreate[$paramId] = array('param' => $newParam, 'dateModif' => $dateModif);
+	}
  
 	public function getLocalParamsToCreate()
 	{