PhysicalDevice/Machine/MachineryECOM/Trunk/DIOS.Dev.Machinery.Common/DIOS.Dev.Machinery.Base/DigitalTwinLogger.cpp

#include "stdafx.h"
#include "DigitalTwinLogger.h"
#include "LogFacade.h"

using namespace DIOS::Dev::Detail::MachineryECOM;

DigitalTwinLogger *DigitalTwinLogger::m_instance = nullptr;

DigitalTwinLogger::DigitalTwinLogger()
:m_examMode(""),
m_detectorHeight(0.0f),
m_sid(0.0f),
m_initialAngleSensorValue(0),
m_initialHeightSensorValue(0),
m_tomoStartAngleSensorValue(0),
m_tomoStartHeightSensorValue(0),
m_tomoHeightSpeed(0.0f),
m_motionStopAngleSensorValue(0),
m_motionStopHeightSensorValue(0),
m_errorStoped(FALSE),
m_tomoNormalRotatePeriod(0),
m_acc(0.0f),
m_lat(0.0f),
m_sus(0.0f),
m_brk(0.0f),
m_tomoProjectNumber(0),
m_tomoScanAngle(0.0f)
{
}


DigitalTwinLogger::~DigitalTwinLogger()
{
}


DigitalTwinLogger *DigitalTwinLogger::Instance()
{
	if (m_instance == nullptr)
	{
		m_instance = new DigitalTwinLogger();
	}

	return m_instance;
}

void DigitalTwinLogger::Initialize(const std::string &workpath)
{
	SYSTEMTIME st;
	GetLocalTime(&st);
	char tmp[32] = { 0 };
	sprintf_s(tmp, "A_DigitalTwin");
	m_logger = LogFacade::CreateLogger(workpath, tmp);
}

SimpleLog *&DigitalTwinLogger::Get()
{
	return m_logger;
}

template<class T> void DigitalTwinLogger::Receive(const std::string &key, const T& data)
{
}

void DigitalTwinLogger::ReceiveTimePoint()
{
	m_tomoTimeLine.push_back(::GetTickCount64());
}

void DigitalTwinLogger::ReceiveExamMode(const std::string &examMode)
{
	m_examMode = examMode;
}

void DigitalTwinLogger::ReceiveDetectorHeight(float height)
{
	m_detectorHeight = height;
}

void DigitalTwinLogger::ReceiveSID(float sid)
{
	m_sid = sid;
}

void DigitalTwinLogger::ReceiveTomoScanParam(int projectNumber, float scanAngle)
{
	m_tomoProjectNumber = projectNumber;
	m_tomoScanAngle = scanAngle;
}

void DigitalTwinLogger::ReceiveMotionInitialPosition(int angleSensorValue, int heightSensorvalue)
{
	m_initialAngleSensorValue = angleSensorValue;
	m_initialHeightSensorValue = heightSensorvalue;
}

void DigitalTwinLogger::ReceiveTomoStartPosition(int angleSensorValue, int heightSensorvalue)
{
	m_tomoStartAngleSensorValue = angleSensorValue;
	m_tomoStartHeightSensorValue = heightSensorvalue;
}

void DigitalTwinLogger::ReceiveTomoExposureAnglePosition(int angleSensorValues)
{
	m_tomoExpAngleSensorValues.push_back(angleSensorValues);
	m_tomoExpATimes.push_back(::GetTickCount64());

}

void DigitalTwinLogger::ReceiveTomoExposureHeightPosition(int heightSensorValue)
{
	m_tomoExpHeightSensorValues.push_back(heightSensorValue);
	m_tomoExpHTimes.push_back(::GetTickCount64());
}

void DigitalTwinLogger::ReceiveTomoSliceRotateSpeeds(int *speeds, int count)
{
	m_tomoSliceRotateSpeeds.clear();

	for (int i = 0; i < count;++i)
	{
		m_tomoSliceRotateSpeeds.push_back(speeds[i]);
	}
}

void DigitalTwinLogger::ReceiveTomoSliceRotateSteps(int *steps, int count)
{
	m_tomoSliceRotateSteps.clear();

	for (int i = 0; i < count; ++i)
	{
		m_tomoSliceRotateSteps.push_back(steps[i]);
	}
}

void DigitalTwinLogger::ReceiveTomoHeightSpeed(float speed)
{
	m_tomoHeightSpeed = speed;
}

void DigitalTwinLogger::ReceiveTomoNormalRotatePeriod(int period)
{
	m_tomoNormalRotatePeriod = period;
}

void DigitalTwinLogger::ReceiveMotionStopPosition(int angleSensorValue, int heightSensorvalue)
{
	m_motionStopAngleSensorValue = angleSensorValue;
	m_motionStopHeightSensorValue = heightSensorvalue;
}

void DigitalTwinLogger::ReceiveTomoProjectParams(float acc, float lat, float sus, float brk)
{
	m_acc = acc;
	m_lat = lat;
	m_sus = sus;
	m_brk = brk;
}

void DigitalTwinLogger::ReceiveTomoProjectSliceParams(float *heights, int heightcount)
{
	m_tomoSliceHeights.clear();

	for (int i = 0; i < heightcount; ++i)
	{
		m_tomoSliceHeights.push_back(heights[i]);
	}
}

void DigitalTwinLogger::ReceiveErrorStop()
{
	m_errorStoped = TRUE;
}

void DigitalTwinLogger::SaveMotionRecord()
{
	if (m_examMode == "")
	{
		return;
	}

	m_logger->Info("-------------------------------------------------\n"
		"[ERR]->[{$:d}]\n"
		"[MD]->[{$},{$:d},{$:f2}]\n"
		"[DTH]->[{$:f6}]\n"
		"[SID]->[{$:f6}]\n"
		"[IAS]->[{$:d}]\n"
		"[IHS]->[{$:d}]\n"
		"[SAS]->[{$:d}]\n"
		"[SHS]->[{$:d}]\n"
		"[EAP]->[{$}]\n"
		"[EHP]->[{$}]\n"
		"[SRS]->[{$}]\n"
		"[SRP]->[{$}]\n"
		"[HSP]->[{$:f6}]\n"
		"[EAS]->[{$:d}]\n"
		"[EHS]->[{$:d}]\n"
		"[TRP]->[{$:d}]\n"
		"[ACC]->[{$:f6}]\n"
		"[LAT]->[{$:f6}]\n"
		"[SUS]->[{$:f6}]\n"
		"[BRK]->[{$:f6}]\n"
		"[TPH]->[{$}]\n"
		"[TML]->[{$}]\n",
		m_errorStoped,
		m_examMode.c_str(), m_tomoProjectNumber, m_tomoScanAngle,
		m_detectorHeight,
		m_sid,
		m_initialAngleSensorValue,
		m_initialHeightSensorValue,
		m_tomoStartAngleSensorValue,
		m_tomoStartHeightSensorValue,
		FormatPairs(m_tomoExpAngleSensorValues, m_tomoExpATimes).c_str(),
		FormatPairs(m_tomoExpHeightSensorValues, m_tomoExpHTimes).c_str(),
		FormatIntVectors(m_tomoSliceRotateSpeeds).c_str(),
		FormatIntVectors(m_tomoSliceRotateSteps).c_str(),
		m_tomoHeightSpeed,
		m_motionStopAngleSensorValue,
		m_motionStopHeightSensorValue,
		m_tomoNormalRotatePeriod,
		m_acc,
		m_lat,
		m_sus,
		m_brk,
		FormatFloatVectors(m_tomoSliceHeights).c_str(),
		FormatLLongVectors(m_tomoTimeLine).c_str()
	);

	Clear();
}

void DigitalTwinLogger::Clear()
{
	m_examMode = "";
	m_tomoExpAngleSensorValues.clear();
	m_tomoExpHeightSensorValues.clear();
	m_tomoSliceRotateSpeeds.clear();
	m_tomoSliceRotateSteps.clear();
	m_tomoExpATimes.clear();
	m_tomoExpHTimes.clear();
	m_errorStoped = FALSE;
	m_tomoSliceHeights.clear();
	m_tomoTimeLine.clear();
}

std::string DigitalTwinLogger::FormatIntVectors(std::vector<int> &params)
{
	std::string ret = "";
	
	for (size_t i = 0; i < params.size();++i)
	{
		if (i != params.size()-1)
		{
			char tmp[10] = { 0 };
			sprintf_s(tmp, "%d,", params[i]);
			ret += std::string(tmp);
		}
		else
		{
			char tmp[10] = { 0 };
			sprintf_s(tmp, "%d", params[i]);
			ret += std::string(tmp);
		}
	}

	ret += "";

	return ret;
}

std::string DigitalTwinLogger::FormatFloatVectors(std::vector<float> &params)
{
	std::string ret = "";

	for (size_t i = 0; i < params.size(); ++i)
	{
		if (i != params.size() - 1)
		{
			char tmp[16] = { 0 };
			sprintf_s(tmp, "%.6f,", params[i]);
			ret += std::string(tmp);
		}
		else
		{
			char tmp[16] = { 0 };
			sprintf_s(tmp, "%.6f", params[i]);
			ret += std::string(tmp);
		}
	}

	ret += "";

	return ret;
}

std::string DigitalTwinLogger::FormatLLongVectors(std::vector<ULONGLONG> &params)
{
	std::string ret = "";

	for (size_t i = 0; i < params.size(); ++i)
	{
		if (i != params.size() - 1)
		{
			char tmp[16] = { 0 };
			sprintf_s(tmp, "%lld,", params[i]);
			ret += std::string(tmp);
		}
		else
		{
			char tmp[16] = { 0 };
			sprintf_s(tmp, "%lld", params[i]);
			ret += std::string(tmp);
		}
	}

	ret += "";

	return ret;
}

std::string DigitalTwinLogger::FormatPairs(std::vector<int> &params, std::vector<ULONGLONG> &ticks)
{
	if (params.size() != ticks.size())
	{
		return "";
	}

	std::string ret = "";

	for (size_t i = 0; i < params.size(); ++i)
	{
		if (i != params.size() - 1)
		{
			char tmp[32] = { 0 };
			sprintf_s(tmp, "(%d,%lld),", params[i], ticks[i]);
			ret += std::string(tmp);
		}
		else
		{
			char tmp[32] = { 0 };
			sprintf_s(tmp, "(%d,%lld)", params[i], ticks[i]);
			ret += std::string(tmp);
		}
	}

	ret += "";

	return ret;
}