// Object properties
#define OBJECTNAME "Advanced Configurator"
/*
#define VERSION "1.01"
#define LASTDATE "2013-01-25"
#define AUTHOR "Ivo Carvalho - ivoc@ipfn.ist.utl.pt"
#define DESCRIPTION "HTML page to change and upload the configuration file parameters"
*/
#define HEADERIMAGELINK "http://www.ipfn.ist.utl.pt/ipfnPortalLayout/themes/ipfn/_img_/logoIPFN_Topo_officialColours.png"
#define FOOTERIMAGELINK "http://backoffice.ipfn.ist.utl.pt/mgallery/default.asp?obj=1"
#include "AdvancedConfigurator.h"
#include "MessageEnvelope.h"
#include "Message.h"
OBJECTLOADREGISTER(AdvancedConfigurator,"$Id: AdvancedConfigurator.cpp,v 1.0 2009/05/22 10:40:56 ivoc Exp $")
/** initialise an object from a set of configs */
bool AdvancedConfigurator::ObjectLoadSetup(ConfigurationDataBase & info, StreamInterface * err){
int i;
delete_selected_points_bool = False;
vector_dim_temp = 0;
already_started = False;
this->graphics_support = new SVGGraphicSupport();
save_filename.Printf("last.cfg");
GCReferenceContainer::ObjectLoadSetup(info,err);
CDBExtended &cdbx = (CDBExtended &)info;
cdbx.ReadFString(configFileID, "configFileID", "cfgFile");
if(!cdbx.ReadFString(Description, "Description"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ObjectLoadSetup: %s Could not read Description",this->Name());
return False;
}
// Move to the colours
if(!cdbx->Move("colours"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ObjectLoadSetup: %s Could not move to \"colours\"",this->Name());
return False;
}
if(!cdbx.ReadFString(header_colour, "header_colour"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ObjectLoadSetup: %s Could not read header_colour",this->Name());
return False;
}
if(!cdbx.ReadFString(colour1, "colour1"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ObjectLoadSetup: %s Could not read colour1",this->Name());
return False;
}
if(!cdbx.ReadFString(colour2, "colour2"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ObjectLoadSetup: %s Could not read colour2",this->Name());
return False;
}
if(!cdbx.ReadFString(colour3, "colour3"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ObjectLoadSetup: %s Could not read colour3",this->Name());
return False;
}
if(!cdbx.ReadFString(colour4, "colour4"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ObjectLoadSetup: %s Could not read colour4",this->Name());
return False;
}
if(!cdbx.ReadFString(colour5, "colour5"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ObjectLoadSetup: %s Could not read colour5",this->Name());
return False;
}
if(!cdbx.ReadFString(footer_colour, "footer_colour"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ObjectLoadSetup: %s Could not read footer_colour",this->Name());
return False;
}
// Move back to the GAM main branch
cdbx->MoveToFather();
// Move to the default directories
if(!cdbx->Move("default_directories"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ObjectLoadSetup: %s Could not move to \"default_directories\"",this->Name());
return False;
}
if(!cdbx.ReadFString(default_config_file_path, "default_config_file_path"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ObjectLoadSetup: %s Could not read default_config_file_path",this->Name());
return False;
}
if(!cdbx.ReadFString(config_files_directory, "config_files_directory"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ObjectLoadSetup: %s Could not read config_files_directory",this->Name());
return False;
}
// Move back to the GAM main branch
cdbx->MoveToFather();
graphic_select = 0;
selected_load_directory = "..";
selected_load_file = "last.cfg";
this->ReadConfigurationFile((char *)default_config_file_path.Buffer());
if(!cdbx.ReadFString(marteLocation, "MARTeLocation", "MARTe")){
AssertErrorCondition(Warning, "ObjectLoadSetup::MARTe location wasn not specified. Using default: %s", marteLocation.Buffer());
}
return HttpInterface::ObjectLoadSetup(info,err);
}
bool AdvancedConfigurator::PrintHTTPForm(HtmlStream &hmStream){
FString temp_string_1;
int i;
hmStream.SSPrintf(HtmlTagStreamMode, "div style=\"position: absolute; top: 10px; left: 1050px;\">Units used: Time in milisecondsDistance in milimetersCurrent in Ampere%sFile Description:_____________________________________________________________________________________________Control file to load: Tomography file to load: Tomography active channels (1 to 8): topouterbottomPrimary PSVertical PSHorizontal PSUART port addressZero current pointCurrent step%s%s%s%0.2f%0.4f%s%0.2f%0.4f%s%0.2f%0.4fActuators: Processed: Gas puffing feedback: MARTe Configuration MinimumMaximumMinimumMaximumToroidal currentPrimary currentVertical currentHorizontal currentPlasma currentRadial positionVertical positionDensity & HAlphapuffing durationmaximum idle timeminimum idle time% of cycle changeFeedback type: Density HAlpha Density HAlpha Thread priorityRunOnCPU ( ∑ 2n )%.1f A%.1f A%.1f A%.1f A%.1f A%.1f A%.1f A%.1f A%.1f A%.1f A%.1f mm%.1f mm%.1f mm%.1f mm%.1f au%.1f au%.2f ms%.2f ms%.2f ms%.2f %%d%dDischarge Timming online to discharge timebreakdown maximum timeinversion maximum timePuffing output: Time windows, open percentage Time windows with feedback Absolute time, open percentage Preprogrammed + time windows feedback OFF Time windows, open percentage Time windows with feedback Absolute time, open percentage Preprogrammed + time windows feedback OFF Time windows, open percentage Time windows with feedback Absolute time, open percentage Preprogrammed + time windows feedback OFF Time windows, open percentage Time windows with feedback Absolute time, open percentage Preprogrammed + time windows feedback OFF Time windows, open percentage Time windows with feedback Absolute time, open percentage Preprogrammed + time windows feedback OFF %0.3f%0.3f%d µs%d µs%d µs 0\"");
if(graphic_select == 0) hmStream.SSPrintf(HtmlTagStreamMode, "option selected=\"selected\" value=0>Primary breakdown to Ip > 0Primary breakdown to Ip > 0Vertical breakdown to Ip > 0Vertical breakdown to Ip > 0Horizontal breakdown to Ip > 0Horizontal breakdown to Ip > 0Primary breakdown to Ip < 0Primary breakdown to Ip < 0Vertical breakdown to Ip < 0Vertical breakdown to Ip < 0Horizontal breakdown to Ip < 0Horizontal breakdown to Ip < 0Primary inversion to Ip < 0Primary inversion to Ip < 0Vertical inversion to Ip < 0Vertical inversion to Ip < 0Horizontal inversion to Ip < 0Horizontal inversion to Ip < 0 0\"");
if(graphic_select == 9) hmStream.SSPrintf(HtmlTagStreamMode, "option selected=\"selected\" value=9>Primary inversion to Ip > 0Primary inversion to Ip > 0Vertical inversion to Ip > 0Vertical inversion to Ip > 0Horizontal inversion to Ip > 0Horizontal inversion to Ip > 0Toroidal currentToroidal currentPuffing output %, Ip > 0Puffing output %, Ip > 0Puffing output %, Ip < 0Puffing output %, Ip < 0Feedback, Ip > 0Feedback, Ip > 0Feedback, Ip < 0Feedback, Ip < 0puffing output (absolute time)puffing output (absolute time)graphics_support->OptimalDisplayFromVectors(primary_breakdown_vector_size, &primary_breakdown_index_vector[0], &primary_breakdown_data_vector[0],&xmin,&ymin,&xmax,&ymax,&majortickx,&majorticky,&number_of_sub_ticks_x,&number_of_sub_ticks_y);
this->graphics_support->GetGraphSVG(&temp_string_1,(char *) this->Name(),primary_breakdown_vector_size,&primary_breakdown_index_vector[0],&primary_breakdown_data_vector[0], 760, 400,xmin,ymin,xmax,ymax,majortickx,majorticky,number_of_sub_ticks_x,number_of_sub_ticks_y, True,True);
hmStream.SSPrintf(HtmlTagStreamMode, "div style=\"position: absolute; top: 490px; left: 320px;\"");
hmStream.SSPrintf(HtmlTagStreamMode, temp_string_1.Buffer());
hmStream.SSPrintf(HtmlTagStreamMode, "/div");
hmStream.SSPrintf(HtmlTagStreamMode, "div style=\"position: absolute; top: 540px; left: 1085px;\"");
hmStream.SSPrintf(HtmlTagStreamMode, "select NAME=\"form_select_waveform_points_0\" size=\"14\" onchange='this.form.submit()'");
for (i=0;i%.2f | %.2ft =%.2f | %.2ft =%.2f | %.2ft =%.2f | %.2ft =%.2f | %.2ft =%.2f | %.2ft =%.2f | %.2ft =%.2f | %.2ft =%.2f | %.2ft =%.2f | %.2ft =%.2f | %.2ft =%.2f | %.2ft =%.2f | %.2ft =%.2f | %.2ft =%.2f | %.2ft =%.2f | %.2ft =18 Min: %.1f x1018 graphics_support->OptimalDisplayFromVectors(puffing_2_n_vector_size, &puffing_2_n_index_vector[0], &puffing_2_n_data_vector[0],&xmin,&ymin,&xmax,&ymax,&majortickx,&majorticky,&number_of_sub_ticks_x,&number_of_sub_ticks_y);
this->graphics_support->GetGraphSVG(&temp_string_1,(char *) this->Name(),puffing_2_n_vector_size,&puffing_2_n_index_vector[0],&puffing_2_n_data_vector[0], 760, 400,xmin,ymin,xmax,ymax,majortickx,majorticky,number_of_sub_ticks_x,number_of_sub_ticks_y, True,True);
hmStream.SSPrintf(HtmlTagStreamMode, "div style=\"position: absolute; top: 490px; left: 320px;\"");
hmStream.SSPrintf(HtmlTagStreamMode, temp_string_1.Buffer());
hmStream.SSPrintf(HtmlTagStreamMode, "/div");
hmStream.SSPrintf(HtmlTagStreamMode, "div style=\"position: absolute; top: 540px; left: 1085px;\"");
hmStream.SSPrintf(HtmlTagStreamMode, "select NAME=\"form_select_waveform_points_16\" size=\"14\" onchange='this.form.submit()'");
for (i=0;i%.2f | %.2ft =18 Min: %.1f x1018 graphics_support->OptimalDisplayFromVectors(puffing_absolute_time_vector_size, &puffing_absolute_time_index_vector[0], &puffing_absolute_time_data_vector[0],&xmin,&ymin,&xmax,&ymax,&majortickx,&majorticky,&number_of_sub_ticks_x,&number_of_sub_ticks_y);
this->graphics_support->GetGraphSVG(&temp_string_1,(char *) this->Name(),puffing_absolute_time_vector_size,&puffing_absolute_time_index_vector[0],&puffing_absolute_time_data_vector[0], 760, 400,xmin,ymin,xmax,ymax,majortickx,majorticky,number_of_sub_ticks_x,number_of_sub_ticks_y, True,True);
hmStream.SSPrintf(HtmlTagStreamMode, "div style=\"position: absolute; top: 490px; left: 320px;\"");
hmStream.SSPrintf(HtmlTagStreamMode, temp_string_1.Buffer());
hmStream.SSPrintf(HtmlTagStreamMode, "/div");
hmStream.SSPrintf(HtmlTagStreamMode, "div style=\"position: absolute; top: 540px; left: 1085px;\"");
hmStream.SSPrintf(HtmlTagStreamMode, "select NAME=\"form_select_waveform_points_17\" size=\"14\" onchange='this.form.submit()'");
for (i=0;i%.2f | %.2ft =Save and commit options only available after all parameters saved! graphics_support->HeaderSVG(&temp_string_1,(char *) OBJECTNAME, 90, 500, 0,422,87,(char *) HEADERIMAGELINK,10,52, (char *) this->Name(),(char *) header_colour.Buffer());
hmStream.SSPrintf(HtmlTagStreamMode, temp_string_1.Buffer());
hmStream.SSPrintf(HtmlTagStreamMode, "svg width=\"100%\" height=\"%d\" style=\"background-color: %s;\">\n\
\n\
\n\
\n\
General Settings Control Settings Main Settings & Waveforms envelope(GCFT_Create);
GCRTemplate message(GCFT_Create);
message->Init(0, "ChangeConfigFile");
//Insert the cdb
ConfigurationDataBase level1CDB;
// cfgFile.Seek(0);
level1CDB->ReadFromStream(temporary_file);
FString value = "True";
FString key = "RebuildAll";
level1CDB->MoveToRoot();
CDBExtended cdbext(level1CDB);
cdbext.WriteFString(value, key.Buffer());
message->Insert(level1CDB);
//Send the message
envelope->PrepareMessageEnvelope(message, marteLocation.Buffer(), MDRF_ManualReply, this);
GCRTemplate reply;
//prepare the reply
SendMessageAndWait(envelope, reply, TimeoutType(10000));
if(!reply.IsValid()){
AssertErrorCondition(Warning, "Reply from %s isn't valid!", marteLocation.Buffer());
hmStream.SSPrintf(HtmlTagStreamMode, "h1");
hmStream.Printf("Reply from %s isn't valid!\n", marteLocation.Buffer());
hmStream.SSPrintf(HtmlTagStreamMode, "/h1");
}
else{
GCRTemplate replyMessage = reply->GetMessage();
if(!replyMessage.IsValid()){
AssertErrorCondition(Warning, "The reply message from %s is not valid", marteLocation.Buffer());
}
else{
hmStream.SSPrintf(HtmlTagStreamMode, "SCRIPT LANGUAGE=\"javascript\"");
hmStream.SSPrintf(HtmlTagStreamMode,"!----");
hmStream.Printf("alert('FileWasSuccessfullyCommitted')");
hmStream.SSPrintf(HtmlTagStreamMode, "!-- END -->already_started =True;
PrintHTTPForm(hmStream);
hStream.SSPrintf("OutputHttpOtions.Content-Type","text/html");
hStream.WriteReplyHeader(True);
return True;
}
bool AdvancedConfigurator::ReadConfigurationFile(char FilePath[]){
// CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ObjectLoadSetup: FilePath = %s",FilePath);
File temp_file;
FString temp_fstring;
int i;
ConfigurationDataBase cdb;
if(!temp_file.OpenRead(FilePath)){
CStaticAssertErrorCondition(InitialisationError, "ReadWaveformFiles: Failed opening File %s", FilePath );
return False;
}
cdb->ReadFromStream(temp_file);
CDBExtended cdbe(cdb);
FString fstring_temp;
// read real time thread configuration
if(!cdbe->Move("+MARTe.+RealTimeThread"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadInt32(thread_priority, "ThreadPriority"))
{
AssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s thread_priority",this->Name());
return False;
}
else AssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: thread_priority = %d",thread_priority);
if(!cdbe.ReadInt32(run_on_cpu, "RunOnCPU"))
{
AssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s run_on_cpu",this->Name());
return False;
}
else AssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: run_on_cpu = %d",run_on_cpu);
cdbe->MoveToRoot();
// read timewindows
if(!cdbe->Move("+MARTe.+RealTimeThread.+time_windows"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+time_windows\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadInt32(usec_pre_pulse_time, "usec_pre_pulse_time"))
{
AssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s usec_pre_pulse_time",this->Name());
return False;
}
else AssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: usec_pre_pulse_time = %d",usec_pre_pulse_time);
if(!cdbe.ReadInt32(maximum_inversion_usectime, "maximum_inversion_usectime"))
{
AssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s maximum_inversion_usectime",this->Name());
return False;
}
else AssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: maximum_inversion_usectime = %d",maximum_inversion_usectime);
if(!cdbe.ReadInt32(puffing_mode, "puffing_mode"))
{
AssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s puffing_mode",this->Name());
return False;
}
else AssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: puffing_mode = %d",puffing_mode);
if(!cdbe.ReadInt32(i, "end_discharge_after_unsuccess_bool"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s end_discharge_after_unsuccess_bool",this->Name());
temp_file.Close();
return False;
}
else
{
end_discharge_after_unsuccess_bool = (bool)i;
CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: end_discharge_after_unsuccess_bool = %d",end_discharge_after_unsuccess_bool);
}
if(!cdbe.ReadInt32(time_between_online_and_discharge, "time_between_online_and_discharge"))
{
AssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s time_between_online_and_discharge",this->Name());
return False;
}
else AssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: time_between_online_and_discharge = %d",time_between_online_and_discharge);
cdbe->MoveToRoot();
// read control
if(!cdbe->Move("+MARTe.+RealTimeThread.+controller"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+controller\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadFString(control_file_to_load, "file_to_load"))
{
CStaticAssertErrorCondition(InitialisationError,"WaveformsDisplay::ObjectLoadSetup: %s Could not control_file_to_load",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: control_file_to_load = %s",control_file_to_load.Buffer());
if(!cdbe.ReadFloat(puffing_duration_in_puffing_feedback_in_ms, "puffing_duration_in_puffing_feedback_in_ms"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s puffing_duration_in_puffing_feedback_in_ms",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: puffing_duration_in_puffing_feedback_in_ms = %f",puffing_duration_in_puffing_feedback_in_ms);
if(!cdbe.ReadFloat(maximum_idle_time_in_puffing_feedback_in_ms, "maximum_idle_time_in_puffing_feedback_in_ms"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s maximum_idle_time_in_puffing_feedback_in_ms",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: maximum_idle_time_in_puffing_feedback_in_ms = %f",maximum_idle_time_in_puffing_feedback_in_ms);
if(!cdbe.ReadFloat(minimum_idle_time_in_puffing_feedback_in_ms, "minimum_idle_time_in_puffing_feedback_in_ms"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s minimum_idle_time_in_puffing_feedback_in_ms",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: minimum_idle_time_in_puffing_feedback_in_ms = %f",minimum_idle_time_in_puffing_feedback_in_ms);
if(!cdbe.ReadFloat(puffing_feedback_usec_change_percentage_by_cycle, "puffing_feedback_usec_change_percentage_by_cycle"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s puffing_feedback_usec_change_percentage_by_cycle",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: puffing_feedback_usec_change_percentage_by_cycle = %f",puffing_feedback_usec_change_percentage_by_cycle);
if(!cdbe.ReadInt32(puffing_feedback_mode, "puffing_feedback_mode"))
{
AssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s puffing_feedback_mode",this->Name());
return False;
}
else AssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: puffing_feedback_mode = %d",puffing_feedback_mode);
cdbe->MoveToRoot();
// read +machine_protection
if(!cdbe->Move("+MARTe.+RealTimeThread.+machine_protection"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+machine_protection\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadFloat(iron_core_saturation_value, "iron_core_saturation_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s iron_core_saturation_value",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: iron_core_saturation_value = %f",iron_core_saturation_value);
if(!cdbe.ReadFloat(iron_core_dangerous_value, "iron_core_dangerous_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s iron_core_dangerous_value",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: iron_core_dangerous_value = %f",iron_core_dangerous_value);
cdbe->MoveToRoot();
// read +tomography
if(!cdbe->Move("+MARTe.+RealTimeThread.+tomography"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+tomography\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadFString(tomography_file_to_load, "file_to_load"))
{
CStaticAssertErrorCondition(InitialisationError,"WaveformsDisplay::ObjectLoadSetup: %s Could not tomography_file_to_load",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: tomography_file_to_load = %s",tomography_file_to_load.Buffer());
if(!cdbe.ReadInt32(tomography_n_channels, "nch"))
{
AssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s tomography_n_channels",this->Name());
return False;
}
else AssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: tomography_n_channels = %d",tomography_n_channels);
tomography_online_channels =new int[tomography_n_channels];
if(!cdbe.ReadInt32Array(tomography_online_channels, (int *)(&tomography_n_channels), 1, "onlineChannels"))
{
CStaticAssertErrorCondition(InitialisationError,"ReadWaveformFiles: Could not read tomography_online_channels");
temp_file.Close();
return False;
}
else for(i=0;iMoveToRoot();
// read maximum values
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_primary.waveform_mode_1_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_primary.waveform_mode_1_positive\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadFloat(primary_1_p_max_value, "max_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s primary_1_p_max_value",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: primary_1_p_max_value = %f",primary_1_p_max_value);
if(!cdbe.ReadFloat(primary_1_p_min_value, "min_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s primary_1_p_min_value",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: primary_1_p_min_value = %f",primary_1_p_min_value);
cdbe->MoveToRoot();
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_primary.waveform_mode_2_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_primary.waveform_mode_2_positive\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadFloat(primary_2_p_max_value, "max_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s primary_2_p_max_value",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: primary_2_p_max_value = %f",primary_2_p_max_value);
if(!cdbe.ReadFloat(primary_2_p_min_value, "min_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s primary_2_p_min_value",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: primary_2_p_min_value = %f",primary_2_p_min_value);
cdbe->MoveToRoot();
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_vertical.waveform_mode_1_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_vertical.waveform_mode_1_positive\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadFloat(vertical_1_p_max_value, "max_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s vertical_1_p_max_value",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: vertical_1_p_max_value = %f",vertical_1_p_max_value);
if(!cdbe.ReadFloat(vertical_1_p_min_value, "min_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s vertical_1_p_min_value",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: vertical_1_p_min_value = %f",vertical_1_p_min_value);
cdbe->MoveToRoot();
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_vertical.waveform_mode_2_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_vertical.waveform_mode_2_positive\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadFloat(vertical_2_p_max_value, "max_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s vertical_2_p_max_value",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: vertical_2_p_max_value = %f",vertical_2_p_max_value);
if(!cdbe.ReadFloat(vertical_2_p_min_value, "min_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s vertical_2_p_min_value",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: vertical_2_p_min_value = %f",vertical_2_p_min_value);
cdbe->MoveToRoot();
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_horizontal.waveform_mode_1_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_horizontal.waveform_mode_1_positive\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadFloat(horizontal_1_p_max_value, "max_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s horizontal_1_p_max_value",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: horizontal_1_p_max_value = %f",horizontal_1_p_max_value);
if(!cdbe.ReadFloat(horizontal_1_p_min_value, "min_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s horizontal_1_p_min_value",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: horizontal_1_p_min_value = %f",horizontal_1_p_min_value);
cdbe->MoveToRoot();
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_horizontal.waveform_mode_2_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_horizontal.waveform_mode_2_positive\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadFloat(horizontal_2_p_max_value, "max_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s horizontal_2_p_max_value",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: horizontal_2_p_max_value = %f",horizontal_2_p_max_value);
if(!cdbe.ReadFloat(horizontal_2_p_min_value, "min_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s horizontal_2_p_min_value",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: horizontal_2_p_min_value = %f",horizontal_2_p_min_value);
cdbe->MoveToRoot();
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_toroidal.waveform_mode_1_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_toroidal.waveform_mode_2_positive\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadFloat(toroidal_1_p_max_value, "max_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s toroidal_1_p_max_value",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: toroidal_1_p_max_value = %f",toroidal_1_p_max_value);
if(!cdbe.ReadFloat(toroidal_1_p_min_value, "min_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s toroidal_1_p_min_value",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: toroidal_1_p_min_value = %f",toroidal_1_p_min_value);
cdbe->MoveToRoot();
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_puffing.waveform_mode_1_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_puffing.waveform_mode_1_positive\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadFloat(puffing_1_p_max_value, "max_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s puffing_1_p_max_value",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: puffing_1_p_max_value = %f",puffing_1_p_max_value);
if(!cdbe.ReadFloat(puffing_1_p_min_value, "min_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s puffing_1_p_min_value",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: puffing_1_p_min_value = %f",puffing_1_p_min_value);
cdbe->MoveToRoot();
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_puffing.waveform_mode_2_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_puffing.waveform_mode_2_positive\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadFloat(puffing_2_p_max_value, "max_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s puffing_2_p_max_value",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: puffing_2_p_max_value = %f",puffing_2_p_max_value);
if(!cdbe.ReadFloat(puffing_2_p_min_value, "min_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s puffing_2_p_min_value",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: puffing_2_p_min_value = %f",puffing_2_p_min_value);
cdbe->MoveToRoot();
// read config file section: waveform_primary
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_primary.waveform_breakdown"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_primary.waveform_breakdown\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadInt32(primary_breakdown_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s primary_breakdown_vector_size",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: primary_breakdown_vector_size = %d",primary_breakdown_vector_size);
primary_breakdown_index_vector =new float[primary_breakdown_vector_size];
primary_breakdown_data_vector =new float[primary_breakdown_vector_size];
if(!cdbe.ReadFloatArray(primary_breakdown_index_vector, (int *)(&primary_breakdown_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"ReadWaveformFiles: Could not read primary_breakdown_index_vector");
temp_file.Close();
return False;
}
else for(i=0;iMoveToRoot();
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_primary.waveform_breakdown_negative"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_primary.waveform_breakdown_negative\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadInt32(primary_breakdown_negative_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s primary_breakdown_negative_vector_size",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: primary_breakdown_negative_vector_size = %d",primary_breakdown_negative_vector_size);
primary_breakdown_negative_index_vector =new float[primary_breakdown_negative_vector_size];
primary_breakdown_negative_data_vector =new float[primary_breakdown_negative_vector_size];
if(!cdbe.ReadFloatArray(primary_breakdown_negative_index_vector, (int *)(&primary_breakdown_negative_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"ReadWaveformFiles: Could not primary_breakdown_negative_index_vector");
temp_file.Close();
return False;
}
else for(i=0;iMoveToRoot();
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_primary.waveform_inversion_positive_to_negative"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_primary.waveform_inversion_positive_to_negative\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadInt32(primary_inversion_positive_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s primary_inversion_positive_vector_size",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: primary_inversion_positive_vector_size = %d",primary_inversion_positive_vector_size);
primary_inversion_positive_index_vector =new float[primary_inversion_positive_vector_size];
primary_inversion_positive_data_vector =new float[primary_inversion_positive_vector_size];
if(!cdbe.ReadFloatArray(primary_inversion_positive_index_vector, (int *)(&primary_inversion_positive_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"ReadWaveformFiles: Could not read primary_inversion_positive_index_vector");
temp_file.Close();
return False;
}
else for(i=0;iMoveToRoot();
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_primary.waveform_inversion_negative_to_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_primary.waveform_inversion_negative_to_positive\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadInt32(primary_inversion_negative_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s primary_inversion_negative_vector_size",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: primary_inversion_negative_vector_size = %d",primary_inversion_negative_vector_size);
primary_inversion_negative_index_vector =new float[primary_inversion_negative_vector_size];
primary_inversion_negative_data_vector =new float[primary_inversion_negative_vector_size];
if(!cdbe.ReadFloatArray(primary_inversion_negative_index_vector, (int *)(&primary_inversion_negative_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"ReadWaveformFiles: Could not read primary_inversion_negative_index_vector");
temp_file.Close();
return False;
}
else for(i=0;iMoveToRoot();
// read config file section: waveform_vertical
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_vertical.waveform_breakdown"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_vertical.waveform_breakdown\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadInt32(vertical_breakdown_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s vertical_breakdown_vector_size",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: vertical_breakdown_vector_size = %d",vertical_breakdown_vector_size);
vertical_breakdown_index_vector =new float[vertical_breakdown_vector_size];
vertical_breakdown_data_vector =new float[vertical_breakdown_vector_size];
if(!cdbe.ReadFloatArray(vertical_breakdown_index_vector, (int *)(&vertical_breakdown_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"ReadWaveformFiles: Could not read vertical_breakdown_index_vector");
temp_file.Close();
return False;
}
else for(i=0;iMoveToRoot();
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_vertical.waveform_breakdown_negative"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_vertical.waveform_breakdown_negative\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadInt32(vertical_breakdown_negative_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s vertical_breakdown_negative_vector_size",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: vertical_breakdown_negative_vector_size = %d",vertical_breakdown_negative_vector_size);
vertical_breakdown_negative_index_vector =new float[vertical_breakdown_negative_vector_size];
vertical_breakdown_negative_data_vector =new float[vertical_breakdown_negative_vector_size];
if(!cdbe.ReadFloatArray(vertical_breakdown_negative_index_vector, (int *)(&vertical_breakdown_negative_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"ReadWaveformFiles: Could not read vertical_breakdown_negative_index_vector");
temp_file.Close();
return False;
}
else for(i=0;iMoveToRoot();
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_vertical.waveform_inversion_positive_to_negative"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_vertical.waveform_mode_2_positive\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadInt32(vertical_inversion_positive_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s vertical_inversion_positive_vector_size",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: vertical_inversion_positive_vector_size = %d",vertical_inversion_positive_vector_size);
vertical_inversion_positive_index_vector =new float[vertical_inversion_positive_vector_size];
vertical_inversion_positive_data_vector =new float[vertical_inversion_positive_vector_size];
if(!cdbe.ReadFloatArray(vertical_inversion_positive_index_vector, (int *)(&vertical_inversion_positive_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"ReadWaveformFiles: Could not read vertical_inversion_positive_index_vector");
temp_file.Close();
return False;
}
else for(i=0;iMoveToRoot();
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_vertical.waveform_inversion_negative_to_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_vertical.waveform_mode_2_negative\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadInt32(vertical_inversion_negative_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s vertical_inversion_negative_vector_size",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: vertical_inversion_negative_vector_size = %d",vertical_inversion_negative_vector_size);
vertical_inversion_negative_index_vector =new float[vertical_inversion_negative_vector_size];
vertical_inversion_negative_data_vector =new float[vertical_inversion_negative_vector_size];
if(!cdbe.ReadFloatArray(vertical_inversion_negative_index_vector, (int *)(&vertical_inversion_negative_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"ReadWaveformFiles: Could not read vertical_inversion_negative_index_vector");
temp_file.Close();
return False;
}
else for(i=0;iMoveToRoot();
// read config file section: waveform_horizontal
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_horizontal.waveform_breakdown"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_horizontal.waveform_mode_1_positive\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadInt32(horizontal_breakdown_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s horizontal_breakdown_vector_size",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: horizontal_breakdown_vector_size = %d",horizontal_breakdown_vector_size);
horizontal_breakdown_index_vector =new float[horizontal_breakdown_vector_size];
horizontal_breakdown_data_vector =new float[horizontal_breakdown_vector_size];
if(!cdbe.ReadFloatArray(horizontal_breakdown_index_vector, (int *)(&horizontal_breakdown_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"ReadWaveformFiles: Could not read horizontal_breakdown_index_vector");
temp_file.Close();
return False;
}
else for(i=0;iMoveToRoot();
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_horizontal.waveform_breakdown_negative"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_horizontal.waveform_mode_1_negative\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadInt32(horizontal_breakdown_negative_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s horizontal_breakdown_negative_vector_size",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: horizontal_breakdown_negative_vector_size = %d",horizontal_breakdown_negative_vector_size);
horizontal_breakdown_negative_index_vector =new float[horizontal_breakdown_negative_vector_size];
horizontal_breakdown_negative_data_vector =new float[horizontal_breakdown_negative_vector_size];
if(!cdbe.ReadFloatArray(horizontal_breakdown_negative_index_vector, (int *)(&horizontal_breakdown_negative_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"ReadWaveformFiles: Could not read horizontal_breakdown_negative_index_vector");
temp_file.Close();
return False;
}
else for(i=0;iMoveToRoot();
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_horizontal.waveform_inversion_positive_to_negative"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_horizontal.waveform_mode_2_positive\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadInt32(horizontal_inversion_positive_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s horizontal_inversion_positive_vector_size",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: horizontal_inversion_positive_vector_size = %d",horizontal_inversion_positive_vector_size);
horizontal_inversion_positive_index_vector =new float[horizontal_inversion_positive_vector_size];
horizontal_inversion_positive_data_vector =new float[horizontal_inversion_positive_vector_size];
if(!cdbe.ReadFloatArray(horizontal_inversion_positive_index_vector, (int *)(&horizontal_inversion_positive_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"ReadWaveformFiles: Could not read horizontal_inversion_positive_index_vector");
temp_file.Close();
return False;
}
else for(i=0;iMoveToRoot();
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_horizontal.waveform_inversion_negative_to_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_horizontal.waveform_mode_2_negative\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadInt32(horizontal_inversion_negative_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s horizontal_inversion_negative_vector_size",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: horizontal_inversion_negative_vector_size = %d",horizontal_inversion_negative_vector_size);
horizontal_inversion_negative_index_vector =new float[horizontal_inversion_negative_vector_size];
horizontal_inversion_negative_data_vector =new float[horizontal_inversion_negative_vector_size];
if(!cdbe.ReadFloatArray(horizontal_inversion_negative_index_vector, (int *)(&horizontal_inversion_negative_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"ReadWaveformFiles: Could not read horizontal_inversion_negative_index_vector");
temp_file.Close();
return False;
}
else for(i=0;iMoveToRoot();
// read config file section: waveform_toroidal
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_toroidal.waveform_mode_1_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_toroidal.waveform_mode_1_positive\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadInt32(toroidal_1_p_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s toroidal_1_p_vector_size",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: toroidal_1_p_vector_size = %d",toroidal_1_p_vector_size);
toroidal_1_p_index_vector =new float[toroidal_1_p_vector_size];
toroidal_1_p_data_vector =new float[toroidal_1_p_vector_size];
if(!cdbe.ReadFloatArray(toroidal_1_p_index_vector, (int *)(&toroidal_1_p_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"ReadWaveformFiles: Could not read toroidal_1_p_index_vector");
temp_file.Close();
return False;
}
else for(i=0;iMoveToRoot();
// read config file section: waveform_puffing
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_puffing.waveform_mode_1_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_puffing.waveform_mode_1_positive\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadInt32(puffing_1_p_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s puffing_1_p_vector_size",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: puffing_1_p_vector_size = %d",puffing_1_p_vector_size);
puffing_1_p_index_vector =new float[puffing_1_p_vector_size];
puffing_1_p_data_vector =new float[puffing_1_p_vector_size];
if(!cdbe.ReadFloatArray(puffing_1_p_index_vector, (int *)(&puffing_1_p_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"ReadWaveformFiles: Could not read puffing_1_p_index_vector");
temp_file.Close();
return False;
}
else for(i=0;iMoveToRoot();
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_puffing.waveform_mode_1_negative"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_puffing.waveform_mode_1_negative\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadInt32(puffing_1_n_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s puffing_1_n_vector_size",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: puffing_1_n_vector_size = %d",puffing_1_n_vector_size);
puffing_1_n_index_vector =new float[puffing_1_n_vector_size];
puffing_1_n_data_vector =new float[puffing_1_n_vector_size];
if(!cdbe.ReadFloatArray(puffing_1_n_index_vector, (int *)(&puffing_1_n_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"ReadWaveformFiles: Could not read puffing_1_n_index_vector");
temp_file.Close();
return False;
}
else for(i=0;iMoveToRoot();
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_puffing.waveform_mode_2_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_puffing.waveform_mode_2_positive\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadInt32(puffing_2_p_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s puffing_2_p_vector_size",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: puffing_2_p_vector_size = %d",puffing_2_p_vector_size);
puffing_2_p_index_vector =new float[puffing_2_p_vector_size];
puffing_2_p_data_vector =new float[puffing_2_p_vector_size];
if(!cdbe.ReadFloatArray(puffing_2_p_index_vector, (int *)(&puffing_2_p_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"ReadWaveformFiles: Could not read puffing_2_p_index_vector");
temp_file.Close();
return False;
}
else for(i=0;iMoveToRoot();
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_puffing.waveform_mode_2_negative"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_puffing.waveform_mode_2_negative\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadInt32(puffing_2_n_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s puffing_2_n_vector_size",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: puffing_2_n_vector_size = %d",puffing_2_n_vector_size);
puffing_2_n_index_vector =new float[puffing_2_n_vector_size];
puffing_2_n_data_vector =new float[puffing_2_n_vector_size];
if(!cdbe.ReadFloatArray(puffing_2_n_index_vector, (int *)(&puffing_2_n_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"ReadWaveformFiles: Could not read puffing_2_n_index_vector");
temp_file.Close();
return False;
}
else for(i=0;iMoveToRoot();
if(!cdbe->Move("+MARTe.+RealTimeThread.+waveform_puffing.waveform_breakdown"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_puffing.waveform_mode_1_positive\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadInt32(puffing_absolute_time_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s puffing_absolute_time_vector_size",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: puffing_absolute_time_vector_size = %d",puffing_absolute_time_vector_size);
puffing_absolute_time_index_vector = new float[puffing_absolute_time_vector_size];
puffing_absolute_time_data_vector = new float[puffing_absolute_time_vector_size];
if(!cdbe.ReadFloatArray(puffing_absolute_time_index_vector, (int *)(&puffing_absolute_time_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"ReadWaveformFiles: Could not read puffing_absolute_time_index_vector");
temp_file.Close();
return False;
}
else for(i=0;iMoveToRoot();
// read config file section: PSCommunicator_vertical
if(!cdbe->Move("+MARTe.+RealTimeThread.+PSCommunicator_vertical"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+PSCommunicator_vertical\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadFString(verticalPS_UARTPortAddress, "UARTPortAddress"))
{
CStaticAssertErrorCondition(InitialisationError,"WaveformsDisplay::ObjectLoadSetup: %s Could not verticalPS_UARTPortAddress",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: verticalPS_UARTPortAddress = %s",verticalPS_UARTPortAddress.Buffer());
if(!cdbe.ReadFloat(verticalPS_PointOfZeroCurrent, "PointOfZeroCurrent"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s verticalPS_PointOfZeroCurrent",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: verticalPS_PointOfZeroCurrent = %f",verticalPS_PointOfZeroCurrent);
if(!cdbe.ReadFloat(verticalPS_CurrentStep, "CurrentStep"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s verticalPS_CurrentStep",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: verticalPS_CurrentStep = %f",verticalPS_CurrentStep);
cdbe->MoveToRoot();
// read config file section: PSCommunicator_horizontal
if(!cdbe->Move("+MARTe.+RealTimeThread.+PSCommunicator_horizontal"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+PSCommunicator_horizontal\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadFString(horizontalPS_UARTPortAddress, "UARTPortAddress"))
{
CStaticAssertErrorCondition(InitialisationError,"WaveformsDisplay::ObjectLoadSetup: %s Could not horizontalPS_UARTPortAddress",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: horizontalPS_UARTPortAddress = %s",horizontalPS_UARTPortAddress.Buffer());
if(!cdbe.ReadFloat(horizontalPS_PointOfZeroCurrent, "PointOfZeroCurrent"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s horizontalPS_PointOfZeroCurrent",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: horizontalPS_PointOfZeroCurrent = %f",horizontalPS_PointOfZeroCurrent);
if(!cdbe.ReadFloat(horizontalPS_CurrentStep, "CurrentStep"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s horizontalPS_CurrentStep",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: horizontalPS_CurrentStep = %f",horizontalPS_CurrentStep);
cdbe->MoveToRoot();
// read config file section: PSCommunicator_primary
if(!cdbe->Move("+MARTe.+RealTimeThread.+PSCommunicator_primary"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+PSCommunicator_primary\"",this->Name());
temp_file.Close();
return False;
}
if(!cdbe.ReadFString(primaryPS_UARTPortAddress, "UARTPortAddress"))
{
CStaticAssertErrorCondition(InitialisationError,"WaveformsDisplay::ObjectLoadSetup: %s Could not primaryPS_UARTPortAddress",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: primaryPS_UARTPortAddress = %s",primaryPS_UARTPortAddress.Buffer());
if(!cdbe.ReadFloat(primaryPS_PointOfZeroCurrent, "PointOfZeroCurrent"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s primaryPS_PointOfZeroCurrent",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: primaryPS_PointOfZeroCurrent = %f",primaryPS_PointOfZeroCurrent);
if(!cdbe.ReadFloat(primaryPS_CurrentStep, "CurrentStep"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ReadConfigurationFile: %s primaryPS_CurrentStep",this->Name());
temp_file.Close();
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::ReadConfigurationFile: primaryPS_CurrentStep = %f",primaryPS_CurrentStep);
cdbe->MoveToRoot();
temp_file.Close();
return True;
}
bool AdvancedConfigurator::WriteConfigurationFileWithChanges(char BaseFileFilePath[], char TargetFilePath[]){
CDBExtended cdb;
int i;
File configIn;
if(!configIn.OpenRead((char *)BaseFileFilePath)){
printf("AdvancedConfigurator:: Failed opening file %s\n", BaseFileFilePath);
return 0;
}
cdb->ReadFromStream(configIn);
configIn.Close();
// Write real time thread configuration
if(!cdb->Move("+MARTe.+RealTimeThread"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread\"",this->Name());
return False;
}
if(!cdb.WriteInt32(thread_priority, "ThreadPriority"))
{
AssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s thread_priority",this->Name());
return False;
}
else AssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: thread_priority = %d",thread_priority);
if(!cdb.WriteInt32(run_on_cpu, "RunOnCPU"))
{
AssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s run_on_cpu",this->Name());
return False;
}
else AssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: run_on_cpu = %d",run_on_cpu);
cdb->MoveToRoot();
// Write timewindows
if(!cdb->Move("+MARTe.+RealTimeThread.+time_windows"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+time_windows\"",this->Name());
return False;
}
if(!cdb.WriteInt32(usec_pre_pulse_time, "usec_pre_pulse_time"))
{
AssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s usec_pre_pulse_time",this->Name());
return False;
}
else AssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: usec_pre_pulse_time = %d",usec_pre_pulse_time);
if(!cdb.WriteInt32(maximum_inversion_usectime, "maximum_inversion_usectime"))
{
AssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s maximum_inversion_usectime",this->Name());
return False;
}
else AssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: maximum_inversion_usectime = %d",maximum_inversion_usectime);
if(!cdb.WriteInt32(puffing_mode, "puffing_mode"))
{
AssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s puffing_mode",this->Name());
return False;
}
else AssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: puffing_mode = %d",puffing_mode);
if(!cdb.WriteInt32((int) end_discharge_after_unsuccess_bool, "end_discharge_after_unsuccess_bool"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s end_discharge_after_unsuccess_bool",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: end_discharge_after_unsuccess_bool = %d",end_discharge_after_unsuccess_bool);
if(!cdb.WriteInt32(time_between_online_and_discharge, "time_between_online_and_discharge"))
{
AssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s time_between_online_and_discharge",this->Name());
return False;
}
else AssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: time_between_online_and_discharge = %d",time_between_online_and_discharge);
cdb->MoveToRoot();
// Write control
if(!cdb->Move("+MARTe.+RealTimeThread.+controller"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+controller\"",this->Name());
return False;
}
if(!cdb.WriteFString(control_file_to_load, "file_to_load"))
{
CStaticAssertErrorCondition(InitialisationError,"WaveformsDisplay::ObjectLoadSetup: %s Could not control_file_to_load",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: control_file_to_load = %s",control_file_to_load.Buffer());
if(!cdb.WriteFloat(horizontal_1_p_max_value, "maximum_horizontal_current"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s maximum_horizontal_current",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: maximum_horizontal_current = %f",horizontal_1_p_max_value);
if(!cdb.WriteFloat(horizontal_1_p_min_value, "minimum_horizontal_current"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s minimum_horizontal_current",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: minimum_horizontal_current = %f",horizontal_1_p_min_value);
if(!cdb.WriteFloat(vertical_1_p_max_value, "maximum_vertical_current"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s maximum_vertical_current",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: maximum_vertical_current = %f",vertical_1_p_max_value);
if(!cdb.WriteFloat(vertical_1_p_min_value, "minimum_vertical_current"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s minimum_vertical_current",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: minimum_vertical_current = %f",vertical_1_p_min_value);
if(!cdb.WriteFloat(primary_1_p_max_value, "maximum_primary_current"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s maximum_primary_current",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: maximum_primary_current = %f",primary_1_p_max_value);
if(!cdb.WriteFloat(primary_1_p_min_value, "minimum_primary_current"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s minimum_primary_current",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: minimum_primary_current = %f",primary_1_p_min_value);
if(!cdb.WriteFloat(horizontal_2_p_max_value, "maximum_horizontal_position"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s maximum_horizontal_position",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: maximum_horizontal_position = %f",horizontal_2_p_max_value);
if(!cdb.WriteFloat(horizontal_2_p_min_value, "minimum_horizontal_position"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s minimum_horizontal_position",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: minimum_horizontal_position = %f",horizontal_2_p_min_value);
if(!cdb.WriteFloat(vertical_2_p_max_value, "maximum_vertical_position"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s maximum_vertical_position",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: maximum_vertical_position = %f",vertical_2_p_max_value);
if(!cdb.WriteFloat(vertical_2_p_min_value, "minimum_vertical_position"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s minimum_vertical_position",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: minimum_vertical_position = %f",vertical_2_p_min_value);
if(!cdb.WriteFloat(primary_2_p_max_value, "maximum_plasma_current"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s maximum_plasma_current",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: maximum_plasma_current = %f",primary_2_p_max_value);
if(!cdb.WriteFloat(primary_2_p_min_value, "minimum_plasma_current"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s minimum_plasma_current",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: minimum_plasma_current = %f",primary_2_p_min_value);
if(!cdb.WriteFloat(toroidal_1_p_max_value, "maximum_toroidal_current"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s maximum_toroidal_current",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: maximum_toroidal_current = %f",toroidal_1_p_max_value);
if(!cdb.WriteFloat(toroidal_1_p_min_value, "minimum_toroidal_current"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s minimum_toroidal_current",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: minimum_toroidal_current = %f",toroidal_1_p_min_value);
if(!cdb.WriteFloat(puffing_1_p_max_value, "maximum_puffing_output"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s maximum_puffing_output",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: maximum_puffing_output = %f",puffing_1_p_max_value);
if(!cdb.WriteFloat(puffing_1_p_min_value, "minimum_puffing_output"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s minimum_puffing_output",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: minimum_puffing_output = %f",puffing_1_p_min_value);
if(!cdb.WriteFloat(puffing_2_p_max_value, "maximum_density_halpha_scenario"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s maximum_density_halpha_scenario",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: maximum_density_halpha_scenario = %f",puffing_2_p_max_value);
if(!cdb.WriteFloat(puffing_2_p_min_value, "minimum_density_halpha_scenario"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s minimum_density_halpha_scenario",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: minimum_density_halpha_scenario = %f",puffing_2_p_min_value);
if(!cdb.WriteFloat(puffing_duration_in_puffing_feedback_in_ms, "puffing_duration_in_puffing_feedback_in_ms"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s puffing_duration_in_puffing_feedback_in_ms",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: puffing_duration_in_puffing_feedback_in_ms = %f",puffing_duration_in_puffing_feedback_in_ms);
if(!cdb.WriteFloat(maximum_idle_time_in_puffing_feedback_in_ms, "maximum_idle_time_in_puffing_feedback_in_ms"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s maximum_idle_time_in_puffing_feedback_in_ms",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: maximum_idle_time_in_puffing_feedback_in_ms = %f",maximum_idle_time_in_puffing_feedback_in_ms);
if(!cdb.WriteFloat(minimum_idle_time_in_puffing_feedback_in_ms, "minimum_idle_time_in_puffing_feedback_in_ms"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s minimum_idle_time_in_puffing_feedback_in_ms",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: minimum_idle_time_in_puffing_feedback_in_ms = %f",minimum_idle_time_in_puffing_feedback_in_ms);
if(!cdb.WriteFloat(puffing_feedback_usec_change_percentage_by_cycle, "puffing_feedback_usec_change_percentage_by_cycle"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s puffing_feedback_usec_change_percentage_by_cycle",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: puffing_feedback_usec_change_percentage_by_cycle = %f",puffing_feedback_usec_change_percentage_by_cycle);
if(!cdb.WriteInt32(puffing_mode, "puffing_mode"))
{
AssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s puffing_mode",this->Name());
return False;
}
else AssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: puffing_mode = %d",puffing_mode);
if(!cdb.WriteInt32(puffing_feedback_mode, "puffing_feedback_mode"))
{
AssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s puffing_feedback_mode",this->Name());
return False;
}
else AssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: puffing_feedback_mode = %d",puffing_feedback_mode);
if(!cdb.WriteInt32(puffing_mode, "puffing_mode"))
{
AssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s puffing_mode",this->Name());
return False;
}
else AssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: puffing_mode = %d",puffing_mode);
cdb->MoveToRoot();
// Write +machine_protection
if(!cdb->Move("+MARTe.+RealTimeThread.+machine_protection"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+machine_protection\"",this->Name());
return False;
}
if(!cdb.WriteFloat(iron_core_saturation_value, "iron_core_saturation_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s iron_core_saturation_value",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: iron_core_saturation_value = %f",iron_core_saturation_value);
if(!cdb.WriteFloat(iron_core_dangerous_value, "iron_core_dangerous_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s iron_core_dangerous_value",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: iron_core_dangerous_value = %f",iron_core_dangerous_value);
cdb->MoveToRoot();
// Write +tomography
if(!cdb->Move("+MARTe.+RealTimeThread.+tomography"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+tomography\"",this->Name());
return False;
}
if(!cdb.WriteFString(tomography_file_to_load, "file_to_load"))
{
CStaticAssertErrorCondition(InitialisationError,"WaveformsDisplay::ObjectLoadSetup: %s Could not tomography_file_to_load",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: tomography_file_to_load = %s",tomography_file_to_load.Buffer());
if(!cdb.WriteInt32Array(tomography_online_channels, (int *)(&tomography_n_channels), 1, "onlineChannels"))
{
CStaticAssertErrorCondition(InitialisationError,"WriteWaveformFiles: Could not Write tomography_online_channels");
return False;
}
else for(i=0;iMoveToRoot();
// Write maximum values
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_primary.waveform_mode_1_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_primary.waveform_mode_1_positive\"",this->Name());
return False;
}
if(!cdb.WriteFloat(primary_1_p_max_value, "max_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s primary_1_p_max_value",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: primary_1_p_max_value = %f",primary_1_p_max_value);
if(!cdb.WriteFloat(primary_1_p_min_value, "min_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s primary_1_p_min_value",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: primary_1_p_min_value = %f",primary_1_p_min_value);
cdb->MoveToRoot();
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_primary.waveform_mode_2_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_primary.waveform_mode_2_positive\"",this->Name());
return False;
}
if(!cdb.WriteFloat(primary_2_p_max_value, "max_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s primary_2_p_max_value",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: primary_2_p_max_value = %f",primary_2_p_max_value);
if(!cdb.WriteFloat(primary_2_p_min_value, "min_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s primary_2_p_min_value",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: primary_2_p_min_value = %f",primary_2_p_min_value);
cdb->MoveToRoot();
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_vertical.waveform_mode_1_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_vertical.waveform_mode_1_positive\"",this->Name());
return False;
}
if(!cdb.WriteFloat(vertical_1_p_max_value, "max_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s vertical_1_p_max_value",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: vertical_1_p_max_value = %f",vertical_1_p_max_value);
if(!cdb.WriteFloat(vertical_1_p_min_value, "min_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s vertical_1_p_min_value",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: vertical_1_p_min_value = %f",vertical_1_p_min_value);
cdb->MoveToRoot();
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_vertical.waveform_mode_2_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_vertical.waveform_mode_2_positive\"",this->Name());
return False;
}
if(!cdb.WriteFloat(vertical_2_p_max_value, "max_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s vertical_2_p_max_value",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: vertical_2_p_max_value = %f",vertical_2_p_max_value);
if(!cdb.WriteFloat(vertical_2_p_min_value, "min_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s vertical_2_p_min_value",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: vertical_2_p_min_value = %f",vertical_2_p_min_value);
cdb->MoveToRoot();
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_horizontal.waveform_mode_1_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_horizontal.waveform_mode_1_positive\"",this->Name());
return False;
}
if(!cdb.WriteFloat(horizontal_1_p_max_value, "max_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s horizontal_1_p_max_value",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: horizontal_1_p_max_value = %f",horizontal_1_p_max_value);
if(!cdb.WriteFloat(horizontal_1_p_min_value, "min_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s horizontal_1_p_min_value",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: horizontal_1_p_min_value = %f",horizontal_1_p_min_value);
cdb->MoveToRoot();
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_horizontal.waveform_mode_2_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_horizontal.waveform_mode_2_positive\"",this->Name());
return False;
}
if(!cdb.WriteFloat(horizontal_2_p_max_value, "max_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s horizontal_2_p_max_value",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: horizontal_2_p_max_value = %f",horizontal_2_p_max_value);
if(!cdb.WriteFloat(horizontal_2_p_min_value, "min_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s horizontal_2_p_min_value",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: horizontal_2_p_min_value = %f",horizontal_2_p_min_value);
cdb->MoveToRoot();
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_toroidal.waveform_mode_1_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_toroidal.waveform_mode_2_positive\"",this->Name());
return False;
}
if(!cdb.WriteFloat(toroidal_1_p_max_value, "max_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s toroidal_1_p_max_value",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: toroidal_1_p_max_value = %f",toroidal_1_p_max_value);
if(!cdb.WriteFloat(toroidal_1_p_min_value, "min_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s toroidal_1_p_min_value",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: toroidal_1_p_min_value = %f",toroidal_1_p_min_value);
cdb->MoveToRoot();
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_puffing.waveform_mode_1_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_puffing.waveform_mode_1_positive\"",this->Name());
return False;
}
if(!cdb.WriteFloat(puffing_1_p_max_value, "max_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s puffing_1_p_max_value",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: puffing_1_p_max_value = %f",puffing_1_p_max_value);
if(!cdb.WriteFloat(puffing_1_p_min_value, "min_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s puffing_1_p_min_value",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: puffing_1_p_min_value = %f",puffing_1_p_min_value);
cdb->MoveToRoot();
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_puffing.waveform_mode_2_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_puffing.waveform_mode_2_positive\"",this->Name());
return False;
}
if(!cdb.WriteFloat(puffing_2_p_max_value, "max_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s puffing_2_p_max_value",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: puffing_2_p_max_value = %f",puffing_2_p_max_value);
if(!cdb.WriteFloat(puffing_2_p_min_value, "min_value"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s puffing_2_p_min_value",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: puffing_2_p_min_value = %f",puffing_2_p_min_value);
cdb->MoveToRoot();
// write config file section: waveform_primary
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_primary.waveform_breakdown"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_primary.waveform_breakdown\"",this->Name());
return False;
}
if(!cdb.WriteInt32(primary_breakdown_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s primary_breakdown_vector_size",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: primary_breakdown_vector_size = %d",primary_breakdown_vector_size);
if(!cdb.WriteFloatArray(primary_breakdown_index_vector, (int *)(&primary_breakdown_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"WriteWaveformFiles: Could not write primary_breakdown_index_vector");
return False;
}
else for(i=0;iMoveToRoot();
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_primary.waveform_breakdown_negative"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_primary.waveform_breakdown_negative\"",this->Name());
return False;
}
if(!cdb.WriteInt32(primary_breakdown_negative_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s primary_breakdown_negative_vector_size",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: primary_breakdown_negative_vector_size = %d",primary_breakdown_negative_vector_size);
if(!cdb.WriteFloatArray(primary_breakdown_negative_index_vector, (int *)(&primary_breakdown_negative_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"WriteWaveformFiles: Could not write primary_breakdown_negative_index_vector");
return False;
}
else for(i=0;iMoveToRoot();
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_primary.waveform_inversion_positive_to_negative"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_primary.waveform_inversion_positive_to_negative\"",this->Name());
return False;
}
if(!cdb.WriteInt32(primary_inversion_positive_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s primary_inversion_positive_vector_size",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: primary_inversion_positive_vector_size = %d",primary_inversion_positive_vector_size);
if(!cdb.WriteFloatArray(primary_inversion_positive_index_vector, (int *)(&primary_inversion_positive_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"WriteWaveformFiles: Could not write primary_inversion_positive_index_vector");
return False;
}
else for(i=0;iMoveToRoot();
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_primary.waveform_inversion_negative_to_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_inversion_negative_to_positive\"",this->Name());
return False;
}
if(!cdb.WriteInt32(primary_inversion_negative_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s primary_inversion_negative_vector_size",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: primary_inversion_negative_vector_size = %d",primary_inversion_negative_vector_size);
if(!cdb.WriteFloatArray(primary_inversion_negative_index_vector, (int *)(&primary_inversion_negative_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"WriteWaveformFiles: Could not write primary_inversion_negative_index_vector");
return False;
}
else for(i=0;iMoveToRoot();
// write config file section: waveform_vertical
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_vertical.waveform_breakdown"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_vertical.waveform_breakdown\"",this->Name());
return False;
}
if(!cdb.WriteInt32(vertical_breakdown_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s vertical_breakdown_vector_size",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: vertical_breakdown_vector_size = %d",vertical_breakdown_vector_size);
if(!cdb.WriteFloatArray(vertical_breakdown_index_vector, (int *)(&vertical_breakdown_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"WriteWaveformFiles: Could not write vertical_breakdown_index_vector");
return False;
}
else for(i=0;iMoveToRoot();
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_vertical.waveform_breakdown_negative"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_vertical.waveform_breakdown_negative\"",this->Name());
return False;
}
if(!cdb.WriteInt32(vertical_breakdown_negative_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s vertical_breakdown_negative_vector_size",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: vertical_breakdown_negative_vector_size = %d",vertical_breakdown_negative_vector_size);
if(!cdb.WriteFloatArray(vertical_breakdown_negative_index_vector, (int *)(&vertical_breakdown_negative_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"WriteWaveformFiles: Could not write vertical_breakdown_negative_index_vector");
return False;
}
else for(i=0;iMoveToRoot();
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_vertical.waveform_inversion_positive_to_negative"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_vertical.waveform_inversion_positive_to_negative\"",this->Name());
return False;
}
if(!cdb.WriteInt32(vertical_inversion_positive_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s vertical_inversion_positive_vector_size",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: vertical_inversion_positive_vector_size = %d",vertical_inversion_positive_vector_size);
if(!cdb.WriteFloatArray(vertical_inversion_positive_index_vector, (int *)(&vertical_inversion_positive_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"WriteWaveformFiles: Could not write vertical_inversion_positive_index_vector");
return False;
}
else for(i=0;iMoveToRoot();
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_vertical.waveform_inversion_negative_to_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_vertical.waveform_inversion_negative_to_positive\"",this->Name());
return False;
}
if(!cdb.WriteInt32(vertical_inversion_negative_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s vertical_inversion_negative_vector_size",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: vertical_inversion_negative_vector_size = %d",vertical_inversion_negative_vector_size);
if(!cdb.WriteFloatArray(vertical_inversion_negative_index_vector, (int *)(&vertical_inversion_negative_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"WriteWaveformFiles: Could not write vertical_inversion_negative_index_vector");
return False;
}
else for(i=0;iMoveToRoot();
// write config file section: waveform_horizontal
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_horizontal.waveform_breakdown"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_horizontal.waveform_breakdown\"",this->Name());
return False;
}
if(!cdb.WriteInt32(horizontal_breakdown_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s horizontal_breakdown_vector_size",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: horizontal_breakdown_vector_size = %d",horizontal_breakdown_vector_size);
if(!cdb.WriteFloatArray(horizontal_breakdown_index_vector, (int *)(&horizontal_breakdown_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"WriteWaveformFiles: Could not write horizontal_breakdown_index_vector");
return False;
}
else for(i=0;iMoveToRoot();
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_horizontal.waveform_breakdown_negative"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_horizontal.waveform_breakdown_negative\"",this->Name());
return False;
}
if(!cdb.WriteInt32(horizontal_breakdown_negative_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s horizontal_breakdown_negative_vector_size",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: horizontal_breakdown_negative_vector_size = %d",horizontal_breakdown_negative_vector_size);
if(!cdb.WriteFloatArray(horizontal_breakdown_negative_index_vector, (int *)(&horizontal_breakdown_negative_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"WriteWaveformFiles: Could not write horizontal_breakdown_negative_index_vector");
return False;
}
else for(i=0;iMoveToRoot();
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_horizontal.waveform_inversion_positive_to_negative"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_horizontal.waveform_inversion_positive_to_negative\"",this->Name());
return False;
}
if(!cdb.WriteInt32(horizontal_inversion_positive_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s horizontal_inversion_positive_vector_size",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: horizontal_inversion_positive_vector_size = %d",horizontal_inversion_positive_vector_size);
if(!cdb.WriteFloatArray(horizontal_inversion_positive_index_vector, (int *)(&horizontal_inversion_positive_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"WriteWaveformFiles: Could not write horizontal_inversion_positive_index_vector");
return False;
}
else for(i=0;iMoveToRoot();
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_horizontal.waveform_inversion_negative_to_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_horizontal.waveform_inversion_negative_to_positive\"",this->Name());
return False;
}
if(!cdb.WriteInt32(horizontal_inversion_negative_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s horizontal_inversion_negative_vector_size",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: horizontal_inversion_negative_vector_size = %d",horizontal_inversion_negative_vector_size);
if(!cdb.WriteFloatArray(horizontal_inversion_negative_index_vector, (int *)(&horizontal_inversion_negative_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"WriteWaveformFiles: Could not write horizontal_inversion_negative_index_vector");
return False;
}
else for(i=0;iMoveToRoot();
// Write config file section: waveform_toroidal
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_toroidal.waveform_mode_1_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_toroidal.waveform_mode_1_positive\"",this->Name());
return False;
}
if(!cdb.WriteInt32(toroidal_1_p_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s toroidal_1_p_vector_size",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: toroidal_1_p_vector_size = %d",toroidal_1_p_vector_size);
if(!cdb.WriteFloatArray(toroidal_1_p_index_vector, (int *)(&toroidal_1_p_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"WriteWaveformFiles: Could not Write toroidal_1_p_index_vector");
return False;
}
else for(i=0;iMoveToRoot();
// !!!!! very important to have both toroidal waveforms equal (to remain the same with plasma direction change on the WaveformGAM) toroidal in absolute time
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_toroidal.waveform_mode_1_negative"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_toroidal.waveform_mode_1_negative\"",this->Name());
return False;
}
if(!cdb.WriteInt32(toroidal_1_p_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s toroidal_1_p_vector_size",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: toroidal_1_p_vector_size = %d",toroidal_1_p_vector_size);
if(!cdb.WriteFloatArray(toroidal_1_p_index_vector, (int *)(&toroidal_1_p_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"WriteWaveformFiles: Could not Write toroidal_1_p_index_vector");
return False;
}
else for(i=0;iMoveToRoot();
// Write config file section: waveform_puffing
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_puffing.waveform_mode_1_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_puffing.waveform_mode_1_positive\"",this->Name());
return False;
}
if(!cdb.WriteInt32(puffing_1_p_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s puffing_1_p_vector_size",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: puffing_1_p_vector_size = %d",puffing_1_p_vector_size);
if(!cdb.WriteFloatArray(puffing_1_p_index_vector, (int *)(&puffing_1_p_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"WriteWaveformFiles: Could not Write puffing_1_p_index_vector");
return False;
}
else for(i=0;iMoveToRoot();
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_puffing.waveform_mode_1_negative"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_puffing.waveform_mode_1_negative\"",this->Name());
return False;
}
if(!cdb.WriteInt32(puffing_1_n_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s puffing_1_n_vector_size",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: puffing_1_n_vector_size = %d",puffing_1_n_vector_size);
if(!cdb.WriteFloatArray(puffing_1_n_index_vector, (int *)(&puffing_1_n_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"WriteWaveformFiles: Could not Write puffing_1_n_index_vector");
return False;
}
else for(i=0;iMoveToRoot();
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_puffing.waveform_mode_2_positive"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_puffing.waveform_mode_2_positive\"",this->Name());
return False;
}
if(!cdb.WriteInt32(puffing_2_p_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s puffing_2_p_vector_size",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: puffing_2_p_vector_size = %d",puffing_2_p_vector_size);
if(!cdb.WriteFloatArray(puffing_2_p_index_vector, (int *)(&puffing_2_p_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"WriteWaveformFiles: Could not Write puffing_2_p_index_vector");
return False;
}
else for(i=0;iMoveToRoot();
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_puffing.waveform_mode_2_negative"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_puffing.waveform_mode_2_negative\"",this->Name());
return False;
}
if(!cdb.WriteInt32(puffing_2_n_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s puffing_2_n_vector_size",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: puffing_2_n_vector_size = %d",puffing_2_n_vector_size);
if(!cdb.WriteFloatArray(puffing_2_n_index_vector, (int *)(&puffing_2_n_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"WriteWaveformFiles: Could not Write puffing_2_n_index_vector");
return False;
}
else for(i=0;iMoveToRoot();
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_puffing.waveform_breakdown"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_puffing.waveform_breakdown\"",this->Name());
return False;
}
if(!cdb.WriteInt32(puffing_absolute_time_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s puffing_absolute_time_vector_size",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: puffing_absolute_time_vector_size = %d",puffing_absolute_time_vector_size);
if(!cdb.WriteFloatArray(puffing_absolute_time_index_vector, (int *)(&puffing_absolute_time_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"WriteWaveformFiles: Could not Write puffing_absolute_time_index_vector");
return False;
}
else for(i=0;iMoveToRoot();
// !!!!! very important to have both puffing breakdown waveforms equal (to remain the same with plasma direction change on the WaveformGAM) puffing in absolute time
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_puffing.waveform_breakdown_negative"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_puffing.waveform_breakdown_negative\"",this->Name());
return False;
}
if(!cdb.WriteInt32(puffing_absolute_time_vector_size, "vector_size"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s puffing_absolute_time_vector_size",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: puffing_absolute_time_vector_size = %d",puffing_absolute_time_vector_size);
if(!cdb.WriteFloatArray(puffing_absolute_time_index_vector, (int *)(&puffing_absolute_time_vector_size), 1, "index_vector"))
{
CStaticAssertErrorCondition(InitialisationError,"WriteWaveformFiles: Could not Write puffing_absolute_time_index_vector");
return False;
}
else for(i=0;iMoveToRoot();
if(!cdb->Move("+MARTe.+RealTimeThread.+waveform_puffing.input_signals.input_time"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+waveform_puffing.input_signals.input_time\"",this->Name());
return False;
}
FString puffing_time_setting_to_write; // !!!!! use only usecTime or usecDischargeTime in this var, everything else implies a segmentation fault
if (puffing_mode == 3) puffing_time_setting_to_write.Printf("usecTime");
else puffing_time_setting_to_write.Printf("usecDischargeTime");
if(!cdb.WriteFString(puffing_time_setting_to_write, "SignalName"))
{
CStaticAssertErrorCondition(InitialisationError,"WaveformsDisplay::WriteConfigurationFile: %s Could not puffing_time_setting_to_write",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: puffing_time_setting_to_write = %s",puffing_time_setting_to_write.Buffer());
cdb->MoveToRoot();
// write config file section: PSCommunicator_vertical
if(!cdb->Move("+MARTe.+RealTimeThread.+PSCommunicator_vertical"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+PSCommunicator_vertical\"",this->Name());
return False;
}
if(!cdb.WriteFString(verticalPS_UARTPortAddress, "UARTPortAddress"))
{
CStaticAssertErrorCondition(InitialisationError,"WaveformsDisplay::WriteConfigurationFile: %s Could not verticalPS_UARTPortAddress",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: verticalPS_UARTPortAddress = %s",verticalPS_UARTPortAddress.Buffer());
if(!cdb.WriteFloat(verticalPS_PointOfZeroCurrent, "PointOfZeroCurrent"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s verticalPS_PointOfZeroCurrent",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: verticalPS_PointOfZeroCurrent = %f",verticalPS_PointOfZeroCurrent);
if(!cdb.WriteFloat(verticalPS_CurrentStep, "CurrentStep"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s verticalPS_CurrentStep",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: verticalPS_CurrentStep = %f",verticalPS_CurrentStep);
cdb->MoveToRoot();
// write config file section: PSCommunicator_horizontal
if(!cdb->Move("+MARTe.+RealTimeThread.+PSCommunicator_horizontal"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+PSCommunicator_horizontal\"",this->Name());
return False;
}
if(!cdb.WriteFString(horizontalPS_UARTPortAddress, "UARTPortAddress"))
{
CStaticAssertErrorCondition(InitialisationError,"WaveformsDisplay::ObjectLoadSetup: %s Could not horizontalPS_UARTPortAddress",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: horizontalPS_UARTPortAddress = %s",horizontalPS_UARTPortAddress.Buffer());
if(!cdb.WriteFloat(horizontalPS_PointOfZeroCurrent, "PointOfZeroCurrent"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s horizontalPS_PointOfZeroCurrent",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: horizontalPS_PointOfZeroCurrent = %f",horizontalPS_PointOfZeroCurrent);
if(!cdb.WriteFloat(horizontalPS_CurrentStep, "CurrentStep"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s horizontalPS_CurrentStep",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: horizontalPS_CurrentStep = %f",horizontalPS_CurrentStep);
cdb->MoveToRoot();
// write config file section: PSCommunicator_primary
if(!cdb->Move("+MARTe.+RealTimeThread.+PSCommunicator_primary"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s Could not move to \"+MARTe.+RealTimeThread.+PSCommunicator_primary\"",this->Name());
return False;
}
if(!cdb.WriteFString(primaryPS_UARTPortAddress, "UARTPortAddress"))
{
CStaticAssertErrorCondition(InitialisationError,"WaveformsDisplay::ObjectLoadSetup: %s Could not primaryPS_UARTPortAddress",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: primaryPS_UARTPortAddress = %s",primaryPS_UARTPortAddress.Buffer());
if(!cdb.WriteFloat(primaryPS_PointOfZeroCurrent, "PointOfZeroCurrent"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s primaryPS_PointOfZeroCurrent",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: primaryPS_PointOfZeroCurrent = %f",primaryPS_PointOfZeroCurrent);
if(!cdb.WriteFloat(primaryPS_CurrentStep, "CurrentStep"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::WriteConfigurationFile: %s primaryPS_CurrentStep",this->Name());
return False;
}
else CStaticAssertErrorCondition(Information,"AdvancedConfigurator::WriteConfigurationFile: primaryPS_CurrentStep = %f",primaryPS_CurrentStep);
cdb->MoveToRoot();
// Move to the AdvancedConfiguration
if(!cdb->Move("+AdvancedConfiguration"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ObjectLoadSetup: %s Could not move to \"+AdvancedConfiguration.graphics\"",this->Name());
return False;
}
if(!cdb.WriteFString(Description, "Description"))
{
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::ObjectLoadSetup: %s Could not Write Description",this->Name());
return False;
}
cdb->MoveToRoot();
FileEraseFile((char *)TargetFilePath);
File configOut;
if(!configOut.OpenWrite((char *)TargetFilePath)){
printf("AdvancedConfigurator:: Failed open write file %s\n", TargetFilePath);
return 0;
}
//Write cdb to string. Tu vais utilizar esta versao (nao vais guardar num ficheiro, claro). Isto e' o que vai depois ser enviado ao MARTe
// FString cdbString;
cdb->WriteToStream(cdbString);
cdbString.Seek(0);
//Write to file...
cdb->WriteToStream(configOut);
configOut.Close();
return True;
}
bool AdvancedConfigurator::DualVectorSort(int vector_dim, float * vector_x, float * vector_y){
if(vector_dim <1){
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::DualVectorSort, vector_dim lower than 1, vector_dim =%d",vector_dim);
return False;
}
if(vector_dim == 1) return True;
int i;
int alfa;
float temp;
float min = *vector_x;
int pos;
for(alfa=0;alfa temp_max_value) point_to_add_y = temp_max_value;
if (point_to_add_y < temp_min_value) point_to_add_y = temp_min_value;
temp_vector_x[vector_dim_temp] = point_to_add_x;
temp_vector_y[vector_dim_temp] = point_to_add_y;
vector_dim_temp++;
DualVectorSort(vector_dim_temp, &temp_vector_x[0], &temp_vector_y[0]);
RemoveRepeatedValues(&vector_dim_temp, &temp_vector_x[0], &temp_vector_y[0]);
if(!RetrieveFromTemp(option)) return False;
return True;
}
bool AdvancedConfigurator::MoveToTemp(int option){
int i;
if (option ==0){ //primary_breakdown
vector_dim_temp = primary_breakdown_vector_size;
temp_vector_x = new float[primary_breakdown_vector_size];
temp_vector_y = new float[primary_breakdown_vector_size];
for (i=0;i< primary_breakdown_vector_size; i++){
temp_vector_x[i] = primary_breakdown_index_vector[i];
temp_vector_y[i] = primary_breakdown_data_vector[i];
}
}
else if (option ==1){ //vertical_breakdown
vector_dim_temp = vertical_breakdown_vector_size;
temp_vector_x = new float[vertical_breakdown_vector_size];
temp_vector_y = new float[vertical_breakdown_vector_size];
for (i=0;i< vertical_breakdown_vector_size; i++){
temp_vector_x[i] = vertical_breakdown_index_vector[i];
temp_vector_y[i] = vertical_breakdown_data_vector[i];
}
}
else if (option ==2){ //horizontal_breakdown
vector_dim_temp = horizontal_breakdown_vector_size;
temp_vector_x = new float[horizontal_breakdown_vector_size];
temp_vector_y = new float[horizontal_breakdown_vector_size];
for (i=0;i< horizontal_breakdown_vector_size; i++){
temp_vector_x[i] = horizontal_breakdown_index_vector[i];
temp_vector_y[i] = horizontal_breakdown_data_vector[i];
}
}
else if (option ==3){ //primary_breakdown
vector_dim_temp = primary_breakdown_negative_vector_size;
temp_vector_x = new float[primary_breakdown_negative_vector_size];
temp_vector_y = new float[primary_breakdown_negative_vector_size];
for (i=0;i< primary_breakdown_negative_vector_size; i++){
temp_vector_x[i] = primary_breakdown_negative_index_vector[i];
temp_vector_y[i] = primary_breakdown_negative_data_vector[i];
}
}
else if (option ==4){ //vertical_breakdown
vector_dim_temp = vertical_breakdown_negative_vector_size;
temp_vector_x = new float[vertical_breakdown_negative_vector_size];
temp_vector_y = new float[vertical_breakdown_negative_vector_size];
for (i=0;i< vertical_breakdown_negative_vector_size; i++){
temp_vector_x[i] = vertical_breakdown_negative_index_vector[i];
temp_vector_y[i] = vertical_breakdown_negative_data_vector[i];
}
}
else if (option ==5){ //horizontal_breakdown
vector_dim_temp = horizontal_breakdown_negative_vector_size;
temp_vector_x = new float[horizontal_breakdown_negative_vector_size];
temp_vector_y = new float[horizontal_breakdown_negative_vector_size];
for (i=0;i< horizontal_breakdown_negative_vector_size; i++){
temp_vector_x[i] = horizontal_breakdown_negative_index_vector[i];
temp_vector_y[i] = horizontal_breakdown_negative_data_vector[i];
}
}
else if (option ==6){ //primary_inversion
vector_dim_temp = primary_inversion_positive_vector_size;
temp_vector_x = new float[primary_inversion_positive_vector_size];
temp_vector_y = new float[primary_inversion_positive_vector_size];
for (i=0;i< primary_inversion_positive_vector_size; i++){
temp_vector_x[i] = primary_inversion_positive_index_vector[i];
temp_vector_y[i] = primary_inversion_positive_data_vector[i];
}
}
else if (option ==7){ //vertical_inversion
vector_dim_temp = vertical_inversion_positive_vector_size;
temp_vector_x = new float[vertical_inversion_positive_vector_size];
temp_vector_y = new float[vertical_inversion_positive_vector_size];
for (i=0;i< vertical_inversion_positive_vector_size; i++){
temp_vector_x[i] = vertical_inversion_positive_index_vector[i];
temp_vector_y[i] = vertical_inversion_positive_data_vector[i];
}
}
else if (option ==8){ //horizontal_inversion
vector_dim_temp = horizontal_inversion_positive_vector_size;
temp_vector_x = new float[horizontal_inversion_positive_vector_size];
temp_vector_y = new float[horizontal_inversion_positive_vector_size];
for (i=0;i< horizontal_inversion_positive_vector_size; i++){
temp_vector_x[i] = horizontal_inversion_positive_index_vector[i];
temp_vector_y[i] = horizontal_inversion_positive_data_vector[i];
}
}
else if (option ==9){ //primary_inversion
vector_dim_temp = primary_inversion_negative_vector_size;
temp_vector_x = new float[primary_inversion_negative_vector_size];
temp_vector_y = new float[primary_inversion_negative_vector_size];
for (i=0;i< primary_inversion_negative_vector_size; i++){
temp_vector_x[i] = primary_inversion_negative_index_vector[i];
temp_vector_y[i] = primary_inversion_negative_data_vector[i];
}
}
else if (option ==10){ //vertical_inversion
vector_dim_temp = vertical_inversion_negative_vector_size;
temp_vector_x = new float[vertical_inversion_negative_vector_size];
temp_vector_y = new float[vertical_inversion_negative_vector_size];
for (i=0;i< vertical_inversion_negative_vector_size; i++){
temp_vector_x[i] = vertical_inversion_negative_index_vector[i];
temp_vector_y[i] = vertical_inversion_negative_data_vector[i];
}
}
else if (option ==11){ //horizontal_inversion
vector_dim_temp = horizontal_inversion_negative_vector_size;
temp_vector_x = new float[horizontal_inversion_negative_vector_size];
temp_vector_y = new float[horizontal_inversion_negative_vector_size];
for (i=0;i< horizontal_inversion_negative_vector_size; i++){
temp_vector_x[i] = horizontal_inversion_negative_index_vector[i];
temp_vector_y[i] = horizontal_inversion_negative_data_vector[i];
}
}
else if (option ==12){ //toroidal
vector_dim_temp = toroidal_1_p_vector_size;
temp_vector_x = new float[toroidal_1_p_vector_size];
temp_vector_y = new float[toroidal_1_p_vector_size];
for (i=0;i< toroidal_1_p_vector_size; i++){
temp_vector_x[i] = toroidal_1_p_index_vector[i];
temp_vector_y[i] = toroidal_1_p_data_vector[i];
}
}
else if (option ==13){ //puffing_1_p
vector_dim_temp = puffing_1_p_vector_size;
temp_vector_x = new float[puffing_1_p_vector_size];
temp_vector_y = new float[puffing_1_p_vector_size];
for (i=0;i< puffing_1_p_vector_size; i++){
temp_vector_x[i] = puffing_1_p_index_vector[i];
temp_vector_y[i] = puffing_1_p_data_vector[i];
}
}
else if (option ==14){ //puffing_1_n
vector_dim_temp = puffing_1_n_vector_size;
temp_vector_x = new float[puffing_1_n_vector_size];
temp_vector_y = new float[puffing_1_n_vector_size];
for (i=0;i< puffing_1_n_vector_size; i++){
temp_vector_x[i] = puffing_1_n_index_vector[i];
temp_vector_y[i] = puffing_1_n_data_vector[i];
}
}
else if (option ==15){ //puffing_2_p
vector_dim_temp = puffing_2_p_vector_size;
temp_vector_x = new float[puffing_2_p_vector_size];
temp_vector_y = new float[puffing_2_p_vector_size];
for (i=0;i< puffing_2_p_vector_size; i++){
temp_vector_x[i] = puffing_2_p_index_vector[i];
temp_vector_y[i] = puffing_2_p_data_vector[i];
}
}
else if (option ==16){ //puffing_2_n
vector_dim_temp = puffing_2_n_vector_size;
temp_vector_x = new float[puffing_2_n_vector_size];
temp_vector_y = new float[puffing_2_n_vector_size];
for (i=0;i< puffing_2_n_vector_size; i++){
temp_vector_x[i] = puffing_2_n_index_vector[i];
temp_vector_y[i] = puffing_2_n_data_vector[i];
}
}
else if (option ==17){ //puffing_absolute
vector_dim_temp = puffing_absolute_time_vector_size;
temp_vector_x = new float[puffing_absolute_time_vector_size];
temp_vector_y = new float[puffing_absolute_time_vector_size];
for (i=0;i< puffing_absolute_time_vector_size; i++){
temp_vector_x[i] = puffing_absolute_time_index_vector[i];
temp_vector_y[i] = puffing_absolute_time_data_vector[i];
}
}
else {
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::MoveToTemp, option out of bounds, option =%d",option);
return False;
}
return True;
}
bool AdvancedConfigurator::MoveToTempWithLimits(int option){
int i;
if (option ==0){ //primary_breakdown
vector_dim_temp = primary_breakdown_vector_size;
temp_max_value = primary_1_p_max_value;
temp_min_value = primary_1_p_min_value;
temp_vector_x = new float[primary_breakdown_vector_size+1];
temp_vector_y = new float[primary_breakdown_vector_size+1];
for (i=0;i< primary_breakdown_vector_size; i++){
temp_vector_x[i] = primary_breakdown_index_vector[i];
temp_vector_y[i] = primary_breakdown_data_vector[i];
}
}
else if (option ==1){ //vertical_breakdown
vector_dim_temp = vertical_breakdown_vector_size;
temp_max_value = vertical_1_p_max_value;
temp_min_value = vertical_1_p_min_value;
temp_vector_x = new float[vertical_breakdown_vector_size+1];
temp_vector_y = new float[vertical_breakdown_vector_size+1];
for (i=0;i< vertical_breakdown_vector_size; i++){
temp_vector_x[i] = vertical_breakdown_index_vector[i];
temp_vector_y[i] = vertical_breakdown_data_vector[i];
}
}
else if (option ==2){ //horizontal_breakdown
vector_dim_temp = horizontal_breakdown_vector_size;
temp_max_value = horizontal_1_p_max_value;
temp_min_value = horizontal_1_p_min_value;
temp_vector_x = new float[horizontal_breakdown_vector_size+1];
temp_vector_y = new float[horizontal_breakdown_vector_size+1];
for (i=0;i< horizontal_breakdown_vector_size; i++){
temp_vector_x[i] = horizontal_breakdown_index_vector[i];
temp_vector_y[i] = horizontal_breakdown_data_vector[i];
}
}
else if (option ==3){ //primary_breakdown
vector_dim_temp = primary_breakdown_negative_vector_size;
temp_max_value = primary_1_p_max_value;
temp_min_value = primary_1_p_min_value;
temp_vector_x = new float[primary_breakdown_negative_vector_size+1];
temp_vector_y = new float[primary_breakdown_negative_vector_size+1];
for (i=0;i< primary_breakdown_negative_vector_size; i++){
temp_vector_x[i] = primary_breakdown_negative_index_vector[i];
temp_vector_y[i] = primary_breakdown_negative_data_vector[i];
}
}
else if (option ==4){ //vertical_breakdown
vector_dim_temp = vertical_breakdown_negative_vector_size;
temp_max_value = vertical_1_p_max_value;
temp_min_value = vertical_1_p_min_value;
temp_vector_x = new float[vertical_breakdown_negative_vector_size+1];
temp_vector_y = new float[vertical_breakdown_negative_vector_size+1];
for (i=0;i< vertical_breakdown_negative_vector_size; i++){
temp_vector_x[i] = vertical_breakdown_negative_index_vector[i];
temp_vector_y[i] = vertical_breakdown_negative_data_vector[i];
}
}
else if (option ==5){ //horizontal_breakdown
vector_dim_temp = horizontal_breakdown_negative_vector_size;
temp_max_value = horizontal_1_p_max_value;
temp_min_value = horizontal_1_p_min_value;
temp_vector_x = new float[horizontal_breakdown_negative_vector_size+1];
temp_vector_y = new float[horizontal_breakdown_negative_vector_size+1];
for (i=0;i< horizontal_breakdown_negative_vector_size; i++){
temp_vector_x[i] = horizontal_breakdown_negative_index_vector[i];
temp_vector_y[i] = horizontal_breakdown_negative_data_vector[i];
}
}
else if (option ==6){ //primary_inversion
vector_dim_temp = primary_inversion_positive_vector_size;
temp_max_value = primary_1_p_max_value;
temp_min_value = primary_1_p_min_value;
temp_vector_x = new float[primary_inversion_positive_vector_size+1];
temp_vector_y = new float[primary_inversion_positive_vector_size+1];
for (i=0;i< primary_inversion_positive_vector_size; i++){
temp_vector_x[i] = primary_inversion_positive_index_vector[i];
temp_vector_y[i] = primary_inversion_positive_data_vector[i];
}
}
else if (option ==7){ //vertical_inversion
vector_dim_temp = vertical_inversion_positive_vector_size;
temp_max_value = vertical_1_p_max_value;
temp_min_value = vertical_1_p_min_value;
temp_vector_x = new float[vertical_inversion_positive_vector_size+1];
temp_vector_y = new float[vertical_inversion_positive_vector_size+1];
for (i=0;i< vertical_inversion_positive_vector_size; i++){
temp_vector_x[i] = vertical_inversion_positive_index_vector[i];
temp_vector_y[i] = vertical_inversion_positive_data_vector[i];
}
}
else if (option ==8){ //horizontal_inversion
vector_dim_temp = horizontal_inversion_positive_vector_size;
temp_max_value = horizontal_1_p_max_value;
temp_min_value = horizontal_1_p_min_value;
temp_vector_x = new float[horizontal_inversion_positive_vector_size+1];
temp_vector_y = new float[horizontal_inversion_positive_vector_size+1];
for (i=0;i< horizontal_inversion_positive_vector_size; i++){
temp_vector_x[i] = horizontal_inversion_positive_index_vector[i];
temp_vector_y[i] = horizontal_inversion_positive_data_vector[i];
}
}
else if (option ==9){ //primary_inversion
vector_dim_temp = primary_inversion_negative_vector_size;
temp_max_value = primary_1_p_max_value;
temp_min_value = primary_1_p_min_value;
temp_vector_x = new float[primary_inversion_negative_vector_size+1];
temp_vector_y = new float[primary_inversion_negative_vector_size+1];
for (i=0;i< primary_inversion_negative_vector_size; i++){
temp_vector_x[i] = primary_inversion_negative_index_vector[i];
temp_vector_y[i] = primary_inversion_negative_data_vector[i];
}
}
else if (option ==10){ //vertical_inversion
vector_dim_temp = vertical_inversion_negative_vector_size;
temp_max_value = vertical_1_p_max_value;
temp_min_value = vertical_1_p_min_value;
temp_vector_x = new float[vertical_inversion_negative_vector_size+1];
temp_vector_y = new float[vertical_inversion_negative_vector_size+1];
for (i=0;i< vertical_inversion_negative_vector_size; i++){
temp_vector_x[i] = vertical_inversion_negative_index_vector[i];
temp_vector_y[i] = vertical_inversion_negative_data_vector[i];
}
}
else if (option ==11){ //horizontal_inversion
vector_dim_temp = horizontal_inversion_negative_vector_size;
temp_max_value = horizontal_1_p_max_value;
temp_min_value = horizontal_1_p_min_value;
temp_vector_x = new float[horizontal_inversion_negative_vector_size+1];
temp_vector_y = new float[horizontal_inversion_negative_vector_size+1];
for (i=0;i< horizontal_inversion_negative_vector_size; i++){
temp_vector_x[i] = horizontal_inversion_negative_index_vector[i];
temp_vector_y[i] = horizontal_inversion_negative_data_vector[i];
}
}
else if (option ==12){ //toroidal
vector_dim_temp = toroidal_1_p_vector_size;
temp_max_value = toroidal_1_p_max_value;
temp_min_value = toroidal_1_p_min_value;
temp_vector_x = new float[toroidal_1_p_vector_size+1];
temp_vector_y = new float[toroidal_1_p_vector_size+1];
for (i=0;i< toroidal_1_p_vector_size; i++){
temp_vector_x[i] = toroidal_1_p_index_vector[i];
temp_vector_y[i] = toroidal_1_p_data_vector[i];
}
}
else if (option ==13){ //puffing_1_p
vector_dim_temp = puffing_1_p_vector_size;
temp_max_value = puffing_1_p_max_value;
temp_min_value = puffing_1_p_min_value;
temp_vector_x = new float[puffing_1_p_vector_size+1];
temp_vector_y = new float[puffing_1_p_vector_size+1];
for (i=0;i < puffing_1_p_vector_size; i++){
temp_vector_x[i] = puffing_1_p_index_vector[i];
temp_vector_y[i] = puffing_1_p_data_vector[i];
}
}
else if (option ==14){ //puffing_1_n
vector_dim_temp = puffing_1_n_vector_size;
temp_max_value = puffing_1_p_max_value;
temp_min_value = puffing_1_p_min_value;
temp_vector_x = new float[puffing_1_n_vector_size+1];
temp_vector_y = new float[puffing_1_n_vector_size+1];
for (i=0;i< puffing_1_n_vector_size; i++){
temp_vector_x[i] = puffing_1_n_index_vector[i];
temp_vector_y[i] = puffing_1_n_data_vector[i];
}
}
else if (option ==15){ //puffing_2_p
vector_dim_temp = puffing_2_p_vector_size;
temp_max_value = puffing_2_p_max_value;
temp_min_value = puffing_2_p_min_value;
temp_vector_x = new float[puffing_2_p_vector_size+1];
temp_vector_y = new float[puffing_2_p_vector_size+1];
for (i=0;i < puffing_2_p_vector_size; i++){
temp_vector_x[i] = puffing_2_p_index_vector[i];
temp_vector_y[i] = puffing_2_p_data_vector[i];
}
}
else if (option ==16){ //puffing_2_n
vector_dim_temp = puffing_2_n_vector_size;
temp_max_value = puffing_2_p_max_value;
temp_min_value = puffing_2_p_min_value;
temp_vector_x = new float[puffing_2_n_vector_size+1];
temp_vector_y = new float[puffing_2_n_vector_size+1];
for (i=0;i< puffing_2_n_vector_size; i++){
temp_vector_x[i] = puffing_2_n_index_vector[i];
temp_vector_y[i] = puffing_2_n_data_vector[i];
}
}
else if (option ==17){ //puffing_absolute
vector_dim_temp = puffing_absolute_time_vector_size;
temp_max_value = puffing_1_p_max_value;
temp_min_value = puffing_1_p_min_value;
temp_vector_x = new float[puffing_absolute_time_vector_size+1];
temp_vector_y = new float[puffing_absolute_time_vector_size+1];
for (i=0;i< puffing_absolute_time_vector_size; i++){
temp_vector_x[i] = puffing_absolute_time_index_vector[i];
temp_vector_y[i] = puffing_absolute_time_data_vector[i];
}
}
else {
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::MoveToTemp, option out of bounds, option =%d",option);
return False;
}
return True;
}
bool AdvancedConfigurator::RetrieveFromTemp(int option){
int i;
if (option ==0){ //primary_1_p
primary_breakdown_vector_size = vector_dim_temp;
primary_breakdown_index_vector = new float[vector_dim_temp];
primary_breakdown_data_vector = new float[vector_dim_temp];
for (i=0;i< vector_dim_temp; i++){
primary_breakdown_index_vector[i] = temp_vector_x[i];
primary_breakdown_data_vector[i] = temp_vector_y[i];
}
}
else if (option ==1){ //vertical_1_p
vertical_breakdown_vector_size = vector_dim_temp;
vertical_breakdown_index_vector = new float[vector_dim_temp];
vertical_breakdown_data_vector = new float[vector_dim_temp];
for (i=0;i< vector_dim_temp; i++){
vertical_breakdown_index_vector[i] = temp_vector_x[i];
vertical_breakdown_data_vector[i] = temp_vector_y[i];
}
}
else if (option ==2){ //horizontal_1_p
horizontal_breakdown_vector_size = vector_dim_temp;
horizontal_breakdown_index_vector = new float[vector_dim_temp];
horizontal_breakdown_data_vector = new float[vector_dim_temp];
for (i=0;i< vector_dim_temp; i++){
horizontal_breakdown_index_vector[i] = temp_vector_x[i];
horizontal_breakdown_data_vector[i] = temp_vector_y[i];
}
}
else if (option ==3){ //primary_1_n
primary_breakdown_negative_vector_size = vector_dim_temp;
primary_breakdown_negative_index_vector = new float[vector_dim_temp];
primary_breakdown_negative_data_vector = new float[vector_dim_temp];
for (i=0;i< vector_dim_temp; i++){
primary_breakdown_negative_index_vector[i] = temp_vector_x[i];
primary_breakdown_negative_data_vector[i] = temp_vector_y[i];
}
}
else if (option ==4){ //vertical_1_n
vertical_breakdown_negative_vector_size = vector_dim_temp;
vertical_breakdown_negative_index_vector = new float[vector_dim_temp];
vertical_breakdown_negative_data_vector = new float[vector_dim_temp];
for (i=0;i< vector_dim_temp; i++){
vertical_breakdown_negative_index_vector[i] = temp_vector_x[i];
vertical_breakdown_negative_data_vector[i] = temp_vector_y[i];
}
}
else if (option ==5){ //horizontal_1_n
horizontal_breakdown_negative_vector_size = vector_dim_temp;
horizontal_breakdown_negative_index_vector = new float[vector_dim_temp];
horizontal_breakdown_negative_data_vector = new float[vector_dim_temp];
for (i=0;i< vector_dim_temp; i++){
horizontal_breakdown_negative_index_vector[i] = temp_vector_x[i];
horizontal_breakdown_negative_data_vector[i] = temp_vector_y[i];
}
}
else if (option ==6){ //primary_2_p
primary_inversion_positive_vector_size = vector_dim_temp;
primary_inversion_positive_index_vector = new float[vector_dim_temp];
primary_inversion_positive_data_vector = new float[vector_dim_temp];
for (i=0;i< vector_dim_temp; i++){
primary_inversion_positive_index_vector[i] = temp_vector_x[i];
primary_inversion_positive_data_vector[i] = temp_vector_y[i];
}
}
else if (option ==7){ //vertical_2_p
vertical_inversion_positive_vector_size = vector_dim_temp;
vertical_inversion_positive_index_vector = new float[vector_dim_temp];
vertical_inversion_positive_data_vector = new float[vector_dim_temp];
for (i=0;i< vector_dim_temp; i++){
vertical_inversion_positive_index_vector[i] = temp_vector_x[i];
vertical_inversion_positive_data_vector[i] = temp_vector_y[i];
}
}
else if (option ==8){ //horizontal_2_p
horizontal_inversion_positive_vector_size = vector_dim_temp;
horizontal_inversion_positive_index_vector = new float[vector_dim_temp];
horizontal_inversion_positive_data_vector = new float[vector_dim_temp];
for (i=0;i< vector_dim_temp; i++){
horizontal_inversion_positive_index_vector[i] = temp_vector_x[i];
horizontal_inversion_positive_data_vector[i] = temp_vector_y[i];
}
}
else if (option ==9){ //primary_2_n
primary_inversion_negative_vector_size = vector_dim_temp;
primary_inversion_negative_index_vector = new float[vector_dim_temp];
primary_inversion_negative_data_vector = new float[vector_dim_temp];
for (i=0;i< vector_dim_temp; i++){
primary_inversion_negative_index_vector[i] = temp_vector_x[i];
primary_inversion_negative_data_vector[i] = temp_vector_y[i];
}
}
else if (option ==10){ //vertical_2_n
vertical_inversion_negative_vector_size = vector_dim_temp;
vertical_inversion_negative_index_vector = new float[vector_dim_temp];
vertical_inversion_negative_data_vector = new float[vector_dim_temp];
for (i=0;i< vector_dim_temp; i++){
vertical_inversion_negative_index_vector[i] = temp_vector_x[i];
vertical_inversion_negative_data_vector[i] = temp_vector_y[i];
}
}
else if (option ==11){ //horizontal_2_n
horizontal_inversion_negative_vector_size = vector_dim_temp;
horizontal_inversion_negative_index_vector = new float[vector_dim_temp];
horizontal_inversion_negative_data_vector = new float[vector_dim_temp];
for (i=0;i< vector_dim_temp; i++){
horizontal_inversion_negative_index_vector[i] = temp_vector_x[i];
horizontal_inversion_negative_data_vector[i] = temp_vector_y[i];
}
}
else if (option ==12){ //toroidal
toroidal_1_p_vector_size = vector_dim_temp;
toroidal_1_p_index_vector = new float[vector_dim_temp];
toroidal_1_p_data_vector = new float[vector_dim_temp];
for (i=0;i< vector_dim_temp; i++){
toroidal_1_p_index_vector[i] = temp_vector_x[i];
toroidal_1_p_data_vector[i] = temp_vector_y[i];
}
}
else if (option ==13){ //puffing_1_p
puffing_1_p_vector_size = vector_dim_temp;
puffing_1_p_index_vector = new float[vector_dim_temp];
puffing_1_p_data_vector = new float[vector_dim_temp];
for (i=0;i< vector_dim_temp; i++){
puffing_1_p_index_vector[i] = temp_vector_x[i];
puffing_1_p_data_vector[i] = temp_vector_y[i];
}
}
else if (option ==14){ //puffing_1_n
puffing_1_n_vector_size = vector_dim_temp;
puffing_1_n_index_vector = new float[vector_dim_temp];
puffing_1_n_data_vector = new float[vector_dim_temp];
for (i=0;i< vector_dim_temp; i++){
puffing_1_n_index_vector[i] = temp_vector_x[i];
puffing_1_n_data_vector[i] = temp_vector_y[i];
}
}
else if (option ==15){ //puffing_2_p
puffing_2_p_vector_size = vector_dim_temp;
puffing_2_p_index_vector = new float[vector_dim_temp];
puffing_2_p_data_vector = new float[vector_dim_temp];
for (i=0;i< vector_dim_temp; i++){
puffing_2_p_index_vector[i] = temp_vector_x[i];
puffing_2_p_data_vector[i] = temp_vector_y[i];
}
}
else if (option ==16){ //puffing_2_n
puffing_2_n_vector_size = vector_dim_temp;
puffing_2_n_index_vector = new float[vector_dim_temp];
puffing_2_n_data_vector = new float[vector_dim_temp];
for (i=0;i< vector_dim_temp; i++){
puffing_2_n_index_vector[i] = temp_vector_x[i];
puffing_2_n_data_vector[i] = temp_vector_y[i];
}
}
else if (option ==17){ //puffing_absolute_time
puffing_absolute_time_vector_size = vector_dim_temp;
puffing_absolute_time_index_vector = new float[vector_dim_temp];
puffing_absolute_time_data_vector = new float[vector_dim_temp];
for (i=0;i< vector_dim_temp; i++){
puffing_absolute_time_index_vector[i] = temp_vector_x[i];
puffing_absolute_time_data_vector[i] = temp_vector_y[i];
}
}
else {
CStaticAssertErrorCondition(InitialisationError,"AdvancedConfigurator::RemovePoint, option out of bounds, option =%d",option);
return False;
}
return True;
}