First implementation of amdaParameterInfo executable to get information about a parameter

Benjamin Renard
1 parent a6490f4d
Showing 8 changed files with 523 additions and 0 deletions Show diff stats
CMakeLists.txt
src/Parameters/ParamData.hh
src/amdaParameterInfo/CMakeLists.txt
src/amdaParameterInfo/Main.cc
src/amdaParameterInfo/ParameterInfo.cc
src/amdaParameterInfo/ParameterInfo.hh
src/amdaParameterInfo/ParameterInfoFileWriter.cc
src/amdaParameterInfo/ParameterInfoFileWriter.hh
@@ -69,6 +69,7 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} &quot;${CMAKE_SOURCE_DIR}/cmake/modules/&quot;)
     add_subdirectory(src/XMLRequest)
     add_subdirectory(src/amdaXMLRequestorTool)
 	add_subdirectory(src/amdaParameterGenerator)
+	add_subdirectory(src/amdaParameterInfo)
 	add_subdirectory(src/PostProcessing)
     add_subdirectory(src/ParamOutputImpl/Download)
     add_subdirectory(src/ParamOutputImpl/IntervalTrue)
@@ -82,6 +83,7 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} &quot;${CMAKE_SOURCE_DIR}/cmake/modules/&quot;)
     add_subdirectory(src/InternLib)
     add_subdirectory(src/ExternLib/Deriv)
     add_subdirectory(src/ExternLib/Magnitude)
+    #add_subdirectory(src/ExternLib/Morschhauser)
     add_subdirectory(src/ExternLib/Ram_Presure)
 	add_subdirectory(src/ExternLib/TimeShifted)
 	add_subdirectory(src/ExternLib/GetClbInfo)
@@ -88,6 +88,9 @@ public:
 	virtual const char *getParamDataType() = 0;
 	virtual const char *getElementType() = 0;
  
+	virtual unsigned int getDim1()= 0;
+	virtual unsigned int getDim2()= 0;
+
 	unsigned int getDataNumber() { return _blockTimeTab.size(); }
  
 protected:
@@ -133,6 +136,9 @@ public:
  
 	void push(ElementType el) { _dataList.push_back(el); }
  
+	virtual unsigned int getDim1() { return _dim1; }
+	virtual unsigned int getDim2() { return _dim2; }
+
 	/**
 	 * design pattern visitor
 	 * accept a visitor
@@ -0,0 +1,45 @@
+
+PROJECT(amdaParameterInfo)
+
+include_directories(
+    ${CMAKE_HOME_DIRECTORY}/src/helpers/
+    ${CMAKE_HOME_DIRECTORY}/src/Info/
+    ${CMAKE_HOME_DIRECTORY}/src/Common/
+    ${CMAKE_HOME_DIRECTORY}/src/Parameters/
+    ${CMAKE_HOME_DIRECTORY}/src/PostProcessing/
+    ${CMAKE_HOME_DIRECTORY}/src/XMLConfigurator/
+    ${CMAKE_HOME_DIRECTORY}/src/XMLParameterConfigurator/
+    ${CMAKE_HOME_DIRECTORY}/src/Plugins/
+    ${CMAKE_HOME_DIRECTORY}/src/TimeTableCatalog/
+    ${LOG4CXX_INCLUDE_DIR}
+    ${LIBXML2_INCLUDE_DIR}
+    ${Boost_INCLUDE_DIR}
+)
+
+#Configuration de la librairie
+file(
+	GLOB_RECURSE
+	source_files
+	./*
+)
+
+ADD_EXECUTABLE( amdaParameterInfo ${source_files} )
+
+
+target_link_libraries(
+    amdaParameterInfo
+    AMDA_COMMON
+   	${CMAKE_THREAD_LIBS_INIT}
+    Parameters
+	${LOG4CXX_LIBRARIES}
+	${LIBXML2_LIBRARIES}
+	Plugin
+	XMLParameterConfigurator
+    ${BOOST_ROOT}/lib/libboost_system.so 
+    ${BOOST_ROOT}/lib/libboost_thread.so
+	${BOOST_ROOT}/lib/libboost_program_options.so
+	ParamOutputImpl
+	TimeTableCatalog
+	Info
+	${DDCLIENTLIBRARY}
+)
@@ -0,0 +1,103 @@
+/**
+ * Main.cc
+ *  Created on: 18 mar. 2016
+ *      Author: AKKA IS
+ */
+
+#include <iostream>
+
+#include <boost/program_options.hpp>
+
+#include "AMDA-Kernel_Config.hh"
+#include <Application.hh>
+
+// Parameters module include
+#include "ParameterManager.hh"
+#include "Parameter.hh"
+#include "Process.hh"
+#include "ParameterInfo.hh"
+#include "ServicesServer.hh"
+
+using namespace std;
+namespace po = boost::program_options;
+using namespace log4cxx;
+using namespace log4cxx::helpers;
+using namespace AMDA::Parameters;
+
+
+/**
+ * Main function
+ */
+int main(int argc, char *argv[]) {
+	int result = AMDA_EXIT_OK;
+
+	/// Parse command line parameters
+	po::options_description desc("Allowed options");
+
+	desc.add_options()
+		("help,h", "Produce help message")
+		("version,v", "Program version")
+		("parameter,p", po::value< vector<string> >(), "Parameter(s) name")
+	;
+
+	po::positional_options_description p;
+	p.add("parameter", -1);
+
+	po::variables_map vm;
+	po::store(po::command_line_parser(argc, argv).options(desc).positional(p).run(), vm);
+	po::notify(vm);
+
+	if (vm.count("help")) {
+		cout << desc << "\n";
+		return result;
+	}
+	if (vm.count("version")) {
+		cout << "Version: " << AMDA_Kernel_VERSION << "\n";
+		return result;
+	}
+
+	if (!vm.count("parameter")) {
+		return result;
+	}
+
+	AMDA::Common::Application lMain;
+
+	return lMain.main(argc,argv,[&](int argc, char *argv[], AMDA::helpers::Properties& lProperties) -> int {
+
+			vector<string> lParameterList = vm["parameter"].as< vector<string> >();
+
+			///Create ParameterManager and configuration
+			ParameterManager parameterManager;
+			std::string emptyStr;
+			parameterManager.addInputInterval(0, 0, 0, emptyStr, emptyStr, 0);
+
+			if (!lProperties["app.param.gapthreshold"].empty())
+			{
+				double defaultGapThreshold = 0.;
+				defaultGapThreshold = atof(lProperties["app.param.gapthreshold"].c_str());
+				if (defaultGapThreshold > 0.)
+					parameterManager.setDefaultGapThreshold(defaultGapThreshold);
+			}
+
+			for (auto lParamName : lParameterList) {
+				try {
+					///Create Parameter
+					parameterManager.createParameter(lParamName);
+
+					///Generate Output
+					AMDA::Parameters::ParameterInfo* lParameterInfo =
+							new AMDA::Parameters::ParameterInfo(parameterManager);
+					ParamOutputSPtr lParamOutput(lParameterInfo);
+					lParameterInfo->setParamName(lParamName);
+					parameterManager.getParamOutputList().push_back( lParamOutput);
+				} catch (...) {
+				}
+			}
+			/// launch request
+			parameterManager.execute("");
+
+			return result;
+});
+
+}
+
@@ -0,0 +1,161 @@
+/*
+ * ParameterInfo.cc
+ *
+ *  Created on: Mar 18 2016
+ *      Author: b.renard
+ */
+
+#include "ParameterInfo.hh"
+
+#include <boost/algorithm/string.hpp>
+#include <string>
+
+namespace AMDA {
+namespace Parameters {
+
+ParameterInfo::ParameterInfo(ParameterManager& pParameterManager) :
+							ParamOutput(pParameterManager),
+		_parameter(NULL) {
+}
+
+ParameterInfo::~ParameterInfo() {
+}
+
+void ParameterInfo::establishConnection() {
+	_parameter = _parameterManager.getSampledParameter(_paramName, _samplingMode, _samplingValue, _gapThreshold).get();
+	if(_parameter == NULL)  {
+		LOG4CXX_ERROR(_logger,"ParamOutput::init parameter : \""<< _paramName <<"\" Not Exist" );
+		BOOST_THROW_EXCEPTION( ParamOutput_exception());
+	}
+	_parameter->openConnection(this);
+}
+
+
+void ParameterInfo::init() {
+	_parameter->init(this, _timeIntervalList);
+
+	AMDA::ParameterInfo::ParameterInfoFileWriter fileWriter;
+
+	std::stringstream filePath;
+	filePath << "info_" << _paramName.c_str() << ".xml";
+	fileWriter.initWriter(filePath.str().c_str());
+	fileWriter.addAttribute("id", _parameter->getId().c_str());
+
+	unsigned int dim1 = _parameter->getDataWriterTemplate()->getParamData()->getDim1();
+	unsigned int dim2 = _parameter->getDataWriterTemplate()->getParamData()->getDim2();
+
+	//Write dimensions info
+	fileWriter.startElement("dimensions"); /* dimensions */
+	std::string dim_1 = std::to_string(dim1);
+	std::string dim_2 = std::to_string(dim2);
+	fileWriter.addAttribute("dim_1",dim_1.c_str());
+	fileWriter.addAttribute("dim_2",dim_2.c_str());
+	fileWriter.endElement(); /* dimensions */
+
+	//Write components info
+	std::vector<std::string> components = this->getComponents();
+	if (!components.empty()) {
+		fileWriter.startElement("components"); /* components */
+
+		for (int i = 0; i < (int)dim1; ++i) {
+			for (int j = 0; j < (int)dim2; ++j) {
+				fileWriter.startElement("component"); /* component */
+				std::string index_1 = std::to_string(i);
+				std::string index_2 = std::to_string(j);
+
+				fileWriter.addAttribute("index_1",index_1.c_str());
+				if (dim2 > 1)
+					fileWriter.addAttribute("index_2",index_2.c_str());
+				fileWriter.addAttribute("name",(components[i*(int)dim2+j]).c_str());
+				fileWriter.endElement(); /* component */
+			}
+		}
+
+		fileWriter.endElement(); /* components */
+	}
+
+	// Write tables info
+	AMDA::Info::ParamInfoSPtr paramInfo = AMDA::Info::ParamMgr::getInstance()->getParamInfoFromId(_parameter->getInfoId());
+
+	fileWriter.startElement("tables"); /* tables */
+	boost::shared_ptr<AMDA::Info::ParamTable> table1SPtr = paramInfo->getTable(0);
+	if (table1SPtr != nullptr) {
+		this->writeTable(table1SPtr, fileWriter, "dim_1");
+	}
+
+	boost::shared_ptr<AMDA::Info::ParamTable> table2SPtr = paramInfo->getTable(1);
+	if (table2SPtr != nullptr) {
+		this->writeTable(table2SPtr, fileWriter, "dim_2");
+	}
+
+	fileWriter.endElement(); /* tables */
+
+	fileWriter.closeWriter();
+}
+
+std::vector<std::string> ParameterInfo::getComponents() {
+	unsigned int dim1 = _parameter->getDataWriterTemplate()->getParamData()->getDim1();
+	unsigned int dim2 = _parameter->getDataWriterTemplate()->getParamData()->getDim2();
+
+	AMDA::Info::ParamInfoSPtr paramInfo = AMDA::Info::ParamMgr::getInstance()->getParamInfoFromId(_parameter->getInfoId());
+
+	std::vector<std::string> components;
+
+	if ( dim1 * dim2 <= 1 ) //scalar => no components
+		return components;
+
+	std::string componentsStr = paramInfo->getComponents();
+
+	//Split labels
+	boost::split(components,componentsStr,boost::is_any_of(","));
+
+	if (components.size() != dim1 * dim2) {
+		//If labels not defined (or misdefined)
+		components.clear();
+		for (int i = 0; i < (int)dim1; ++i) {
+			for (int j = 0; j < (int)dim2; ++j) {
+				std::string crtComp;
+				crtComp += (!paramInfo->getShortName().empty() ? paramInfo->getShortName() : paramInfo->getId());
+				crtComp += "[";
+				if (dim1 > 1)
+					crtComp += std::to_string(i);
+				if (dim1 > 1 && dim2 > 1)
+					crtComp += ",";
+				if (dim2 > 1)
+					crtComp += std::to_string(j);
+				crtComp += "]";
+				components.push_back(crtComp);
+			}
+		}
+	}
+
+	return components;
+}
+
+void ParameterInfo::writeTable(boost::shared_ptr<AMDA::Info::ParamTable> tableSPtr, AMDA::ParameterInfo::ParameterInfoFileWriter& fileWriter, std::string relatedDim) {
+	if (tableSPtr == nullptr)
+		return;
+	fileWriter.startElement("table"); /* table */
+	fileWriter.addAttribute("relatedDim", relatedDim.c_str() );
+	if (tableSPtr->isVariable()) {
+		fileWriter.addAttribute("variable","true");
+	}
+	else {
+		fileWriter.addAttribute("name",tableSPtr->getName().c_str());
+		fileWriter.addAttribute("units",tableSPtr->getUnits().c_str());
+		for (int i = 0; i < tableSPtr->getSize(&_parameter->getParameterManager()); ++i) {
+			AMDA::Info::t_TableBound bound = tableSPtr->getBound(&_parameter->getParameterManager(),i);
+			fileWriter.startElement("channel"); /* channel */
+			std::string min = std::to_string(bound.min);
+			std::string max = std::to_string(bound.max);
+			fileWriter.addAttribute("min",min.c_str());
+			fileWriter.addAttribute("max",max.c_str());
+			fileWriter.endElement(); /* channel */
+		}
+	}
+	fileWriter.endElement(); /* table */
+}
+
+
+} /* namespace Parameters */
+} /* namespace AMDA */
@@ -0,0 +1,70 @@
+/*
+ * ParameterInfo.hh
+ *
+ *  Created on: Mar 18, 2016
+ *      Author: b.renard
+ */
+
+#ifndef PARAMETERINFO_HH_
+#define PARAMETERINFO_HH_
+
+#include "ParamOutput.hh"
+
+#include "ParamMgr.hh"
+#include "ParameterInfoFileWriter.hh"
+
+namespace AMDA {
+namespace Parameters {
+
+/**
+ * @class ParameterInfo
+ * @brief Get information about a given parameter.
+ * @details
+ */
+class ParameterInfo: public AMDA::Parameters::ParamOutput {
+public:
+	/**
+	 * Constructor.
+	 */
+	ParameterInfo(AMDA::Parameters::ParameterManager& pParameterManager);
+	/**
+	 * Destructor.
+	 */
+	virtual ~ParameterInfo();
+
+	// Getter methods
+	const std::string& getParamName() const { return _paramName; }
+
+	// Setter methods
+	void setParamName(const std::string& paramName) { _paramName = paramName; }
+
+	/**
+	 * @overload DataClient::establishConnection()
+	*/
+	virtual void establishConnection();
+
+	/**
+	 * @overload ParamOutput::apply()
+	 * @brief Empty method.
+	*/
+	 virtual void apply() {}
+
+protected:
+
+	/**
+	 * @overload ParamOutput::init()
+	*/
+	virtual void init();
+
+private:
+	AMDA::Parameters::Parameter* 		 _parameter;
+	std::string      _paramName;
+
+	std::vector<std::string> getComponents();
+
+	void writeTable(boost::shared_ptr<AMDA::Info::ParamTable> table1SPtr, AMDA::ParameterInfo::ParameterInfoFileWriter& fileWriter, std::string relatedDim);
+};
+
+} /* namespace Parameters */
+} /* namespace AMDA */
+#endif /* PARAMETERINFO_HH_ */
@@ -0,0 +1,97 @@
+/*
+ * ParameterInfoFileWriter.cc
+ *
+ *  Created on: 18 mar. 2016
+ *      Author: AKKA
+ */
+
+#include "ParameterInfoFileWriter.hh"
+
+namespace AMDA
+{
+namespace ParameterInfo
+{
+
+
+ParameterInfoFileWriter::ParameterInfoFileWriter() : _writer(NULL) {
+
+}
+
+ParameterInfoFileWriter::~ParameterInfoFileWriter() {
+	closeWriter();
+}
+
+bool ParameterInfoFileWriter::initWriter(const char* filePath) {
+	if (_writer != NULL)
+		return false;
+
+	LIBXML_TEST_VERSION
+
+	_writer = xmlNewTextWriterFilename(filePath, 0);
+	if (_writer == NULL) {
+		return false;
+	}
+
+	int rc;
+	rc = xmlTextWriterStartDocument(_writer, "1.0", "UTF-8", NULL);
+
+	if (rc < 0) {
+		return false;
+	}
+
+	return startElement("paraminfo");
+}
+
+bool ParameterInfoFileWriter::closeWriter() {
+	if (_writer == NULL)
+		return false;
+
+	int rc = xmlTextWriterEndDocument(_writer);
+	if (rc < 0)
+		return false;
+
+	xmlFreeTextWriter(_writer);
+
+	_writer = NULL;
+
+	return true;
+}
+
+bool ParameterInfoFileWriter::startElement(const char* name) {
+	if (_writer == NULL)
+		return false;
+
+	int rc = xmlTextWriterStartElement(_writer, BAD_CAST name);
+	if (rc < 0) {
+		return false;
+	}
+
+	return true;
+}
+
+bool ParameterInfoFileWriter::endElement() {
+	if (_writer == NULL)
+		return false;
+
+	int rc = xmlTextWriterEndElement(_writer);
+	if (rc < 0) {
+		return false;
+	}
+
+	return true;
+}
+
+bool ParameterInfoFileWriter::addAttribute(const char* name, const char* value) {
+	if (_writer == NULL)
+		return false;
+
+	int rc = xmlTextWriterWriteAttribute(_writer, BAD_CAST name, BAD_CAST value);
+	if (rc < 0) {
+		return false;
+	}
+
+	return false;
+}
+
+} /* namespace ParameterInfo */
+} /* namespace AMDA */
@@ -0,0 +1,39 @@
+/*
+ * ParameterInfoFileWriter.hh
+ *
+ *  Created on: 18 mar. 2016
+ *      Author: AKKA
+ */
+
+#ifndef PARAMETERINFOFILEWRITER_HH_
+#define PARAMETERINFOFILEWRITER_HH_
+
+#include <libxml/xmlwriter.h>
+
+namespace AMDA {
+namespace ParameterInfo {
+
+class ParameterInfoFileWriter {
+public:
+	ParameterInfoFileWriter();
+
+	virtual ~ParameterInfoFileWriter();
+
+	bool initWriter(const char* filePath);
+
+	bool closeWriter();
+
+	bool startElement(const char* name);
+
+	bool endElement();
+
+	bool addAttribute(const char* name, const char* value);
+
+private:
+	xmlTextWriterPtr _writer;
+};
+
+} /* namespace ParameterInfo */
+} /* namespace AMDA */
+
+#endif