void CPlotXY::convergence_history( SignalArgs & args )
{
if( is_not_null(m_data.get()) )
{
SignalFrame reply = args.create_reply( uri() );
SignalFrame& options = reply.map( Protocol::Tags::key_options() );
// std::vector<Real> data(8000);
CTable<Real>& table = *m_data.get();
std::vector<std::string> labels =
list_of<std::string>("x")("y")("z")("u")("v")("w")("p")("t");
add_multi_array_in(options.main_map, "Table", m_data->array(), ";", labels);
// for(Uint row = 0 ; row < 1000 ; ++row)
// {
// for(Uint col = 0 ; col < 8 ; ++col)
// data[ (row * 8) + col ] = table[row][col];
// }
// XmlNode node = options.add("Table", data, " ; ");
// node.set_attribute("dimensions", "8");
}
else
throw SetupError( FromHere(), "Data to plot not setup" );
}
void LocalDispatcher::dispatch_signal(const std::string & target, const URI & receiver,
SignalArgs & args)
{
Component & comp = Core::instance().root().access_component( receiver );
args.options().flush();
comp.call_signal( target, args );
}
void C3DViewBuilder::signature_create_3dview(SignalArgs &args)
{
SignalFrame& options = args.map( Protocol::Tags::key_options() );
options.set_option("3DView name", common::class_name<std::string>(), std::string(), "Name for the new 3DView");
options.set_option("Parent", common::class_name<URI>(), Core::instance().root().uri().path(), "Parent of the new component");
}
void ShockTube::signature_create_model( SignalArgs& args )
{
SignalFrame& p = args.map( Protocol::Tags::key_options() );
p.set_option<std::string>("model_name", "shocktube" , "Name for created model" );
p.set_option<Uint>("nb_cells", 100u , "Number of Cells to be generated");
p.set_option<Uint>("dimension", 1u , "Dimension of the problem");
}
void BoundaryConditions::signal_create_function_bc ( SignalArgs& node )
{
SignalOptions options( node );
SignalFrame reply = node.create_reply(uri());
SignalOptions reply_options(reply);
reply_options.add_option("created_component", add_function_bc(options.value<std::string>("region_name"), options.value<std::string>("variable_name"))->uri());
}
void LSSAction::signal_create_lss(SignalArgs& node)
{
SignalOptions options(node);
LSS::System& lss = create_lss(options.option("matrix_builder").value<std::string>());
SignalFrame reply = node.create_reply(uri());
SignalOptions reply_options(reply);
reply_options.add("created_component", lss.uri());
}
void NetworkQueue::dispatch_signal( const std::string & target,
const URI & receiver,
SignalArgs &args )
{
args.options().flush();
Transaction * transaction = send( args, LOW );
if( is_not_null(transaction) )
transaction->from_script = true;
}
void TreeThread::new_signal( SignalArgs & args)
{
const char * tag = Protocol::Tags::node_frame();
if( args.node.is_valid() )
{
SignalFrame real_frame;
if( args.has_reply() )
real_frame = args.get_reply();
else
real_frame = args;
std::string type = real_frame.node.attribute_value("target");
std::string receiver = real_frame.node.attribute_value("receiver");
try
{
Handle< Component > real_root = root();
if(real_root->uri().path() == URI(receiver).path())
root()->call_signal(type, real_frame);
else
real_root->access_component(receiver)->call_signal(type, real_frame);
}
catch(cf3::common::Exception & cfe)
{
NLog::global()->add_exception(/*QString("%1 %2").arg(type.c_str()).arg(receiver.c_str()) + */cfe.what());
}
catch(std::exception & stde)
{
NLog::global()->add_exception(stde.what());
}
catch(...)
{
CFerror << "Unknown exception thrown during execution of action [" << type
<< "] on component " << " [" << receiver << "]." << CFendl;
}
}
}
void N3DView::launch_pvserver( SignalArgs& node ){
SignalFrame& options = node.map( Protocol::Tags::key_options() );
std::vector<std::string> data = options.get_array<std::string>("infoServer");
std::string host = data[0];
std::string port = data[1];
TabBuilder::instance()->getWidget<Widget3D>(as_ptr<CNode>())
->connectToServer(host.c_str(), port.c_str());
}
void Link::change_link( SignalArgs & args )
{
SignalOptions options( args );
SignalFrame reply = args.create_reply();
std::string path = options.value<std::string>("target_path");
Handle<Component> target = access_component(path);
link_to (*target);
reply.map("options").set_option("target_path", class_name<std::string>(), path);
}
void CLink::change_link( SignalArgs & args )
{
SignalOptions options( args );
SignalFrame reply = args.create_reply();
std::string path = options.value<std::string>("target_path");
Component::Ptr target = m_root.lock()->access_component_ptr(path);
link_to (target);
reply.map("options").set_option("target_path", path);
}
void SignalManager::signalSignature(SignalArgs & args)
{
if(m_waitingForSignature)
{
URI path = m_node->realComponent()->uri();
ActionInfo & info = m_signals[m_currentAction];
const char * tag = Protocol::Tags::key_options();
m_frame = SignalFrame(info.name.toStdString(), path, path);
SignalFrame& options = m_frame.map( Protocol::Tags::key_options() );
if( args.has_map(tag) )
args.map(tag).main_map.content.deep_copy( options.main_map.content );
try
{
SignatureDialog * sg = new SignatureDialog();
connect(sg, SIGNAL(finished(int)), this, SLOT(dialogFinished(int)));
sg->show(options.main_map.content, m_currentAction->text());
}
catch( Exception & e)
{
NLog::globalLog()->addException(e.what());
}
catch( ... )
{
NLog::globalLog()->addException("Unknown exception caught");
}
m_waitingForSignature = false;
}
}
void InitialConditions::signal_create_initial_condition(SignalArgs& args)
{
SignalOptions options(args);
Handle<common::Action> ic;
if(options.check("builder_name"))
{
ic = create_initial_condition(options["field_tag"].value<std::string>(), options["builder_name"].value<std::string>());
}
else
{
ic = create_initial_condition(options["field_tag"].value<std::string>());
}
SignalFrame reply = args.create_reply(uri());
SignalOptions reply_options(reply);
reply_options.add("created_component", ic->uri());
}
void N3DView::send_server_info_to_client( SignalArgs& node ){
SignalFrame& options = node.map( Protocol::Tags::key_options() );
std::vector<std::string> data = options.get_array<std::string>("pathinfo");
std::string path = data[0];
std::string name = data[1];
std::vector<QString> path_list(1);
path_list[0] = QString(path.c_str());
std::vector<QString> name_list(1);
name_list[0] = QString(name.c_str());
TabBuilder::instance()->getWidget<Widget3D>(as_ptr<CNode>())
->loadPaths(path_list, name_list);
}
void RemoteDispatcher::send_next_signal( SignalArgs & args )
{
if( m_running )
{
SignalOptions & options = args.options();
std::string frameid = options.value<std::string>( "frameid" );
if( m_currentFrameId == frameid )
{
if ( m_nextIndex <= m_pendingSignals.count() )
{
bool success = options.value<bool>( "success" );
if( !success )
{
std::string message = options.value<std::string>( "message" );
QString msg("Error while running the script. The following error occured : %1"
"\n When executing the signal \n%2");
std::string str;
to_string( m_pendingSignals[m_nextIndex-1].node, str );
NLog::global()->add_exception( msg.arg(message.c_str()).arg(str.c_str()) );
m_running = false;
emit finished();
}
else
{
NLog::global()->add_message( QString("Frame %1 was ack'ed").arg(frameid.c_str()) );
send_signal( m_nextIndex );
m_nextIndex++;
}
}
else
{
m_running = false;
// m_connectionManager->manage_connection("ack")->disconnect();
NLog::global()->add_message("Script is finished");
emit finished();
}
}
}
}
void NPlotXY::convergence_history ( SignalArgs& node )
{
SignalFrame& options = node.map( Protocol::Tags::key_options() );
PlotDataPtr array( new PlotData() );
std::vector<std::string> labels;
get_multi_array(options.main_map, "Table", *array, labels);
int nbRows = array->size();
int nbCols = (*array)[0].size();
std::vector<QString> fct_label(labels.size() + 1);
fct_label[0] = "#";
for(int i = 0 ; i < labels.size() ; ++i)
fct_label[i+1] = labels[i].c_str();
// Store last dimension, then first, then middle
PlotData::size_type ordering[] = {0, 1};
// Store the first dimension(dimension 0) in descending order
bool ascending[] = {true, true};
PlotDataPtr plot( new PlotData(boost::extents[nbRows][nbCols+1],
boost::general_storage_order<2>(ordering, ascending)) );
for(PlotData::index row = 0;row<nbRows;++row)
{
(*plot)[row][0] = row;
}
for(PlotData::index row = 0; row != nbRows; ++row)
{
for(PlotData::index col = 0; col != nbCols; ++col)
(*plot)[row][col+1] = (*array)[row][col];
}
TabBuilder::instance()->widget<Graph>(handle<CNode>())->set_xy_data(plot, fct_label);
}
void InitialConditions::signal_create_initial_condition ( SignalArgs& args )
{
SignalOptions options( args );
std::string name = options.value<std::string>("name");
std::vector<URI> regions;
if( options.check("regions") )
{
regions = options.array<URI>("regions");
}
else // if user did not specify, then use the whole topology (all regions)
{
regions = solver().options().option("regions").value< std::vector<common::URI> >();
}
solver::Action& created_component = create_initial_condition(name,regions);
SignalFrame reply = args.create_reply(uri());
SignalOptions reply_options(reply);
reply_options.add_option("created_component", created_component.uri());
}
void TCPConnection::prepare_write_buffers( SignalArgs & args,
std::vector<asio::const_buffer> & buffers )
{
cf3_assert( args.node.is_valid() );
// prepare the outgoing data: flush to XML and convert to string
args.flush_maps();
XML::to_string( *args.xml_doc.get(), m_outgoing_data );
// create the header on HEADER_LENGTH characters
std::ostringstream header_stream;
header_stream << std::setw(HEADER_LENGTH) << m_outgoing_data.length();
m_outgoing_header = header_stream.str();
// write header and data to buffers and then on the socket
buffers.push_back( asio::buffer(m_outgoing_header) );
buffers.push_back( asio::buffer(m_outgoing_data) );
// std::cout << "[" << m_outgoing_header << "]" << std::endl;
// std::cout << m_outgoing_data.size() << " => " << m_outgoing_data << std::endl;
}
void ShockTube::signal_create_model ( SignalArgs& args )
{
SignalFrame& p = args.map( Protocol::Tags::key_options() );
////////////////////////////////////////////////////////////////////////////////
// Create Model
////////////////////////////////////////////////////////////////////////////////
std::string name = p.get_option<std::string>("model_name");
CFinfo << "Creating model " << name << CFendl;
CModelUnsteady& model = *Common::Core::instance().root().create_component_ptr<CModelUnsteady>( name );
////////////////////////////////////////////////////////////////////////////////
// Create Physics
////////////////////////////////////////////////////////////////////////////////
CFinfo << "Creating physics" << CFendl;
Physics::PhysModel& physics = model.create_physics("physics");
physics.configure_option( "Dimensions", p.get_option<Uint>("dimension") );
////////////////////////////////////////////////////////////////////////////////
// Create tools
////////////////////////////////////////////////////////////////////////////////
CMeshTransformer& finite_volume_transformer = model.tools().create_component<CMeshTransformer>("FiniteVolumeTransformer");
finite_volume_transformer.create_component_ptr<CBuildFaces> ("1_build_faces")->mark_basic();
finite_volume_transformer.create_component_ptr<BuildGhostStates>("2_build_ghoststates")->mark_basic();
finite_volume_transformer.create_component_ptr<CreateSpaceP0> ("3_create_space_P0")->mark_basic();
finite_volume_transformer.create_component_ptr<CBuildVolume> ("4_build_volume_field")->mark_basic();
////////////////////////////////////////////////////////////////////////////////
// Generate mesh
////////////////////////////////////////////////////////////////////////////////
CFinfo << "Creating domain" << CFendl;
CDomain& domain = model.create_domain("domain");
CMesh::Ptr mesh_ptr;
CFinfo << " Generating mesh with " << p.get_option<Uint>("nb_cells") << " cells per dimension" <<CFendl;
switch (p.get_option<Uint>("dimension"))
{
case 1:
mesh_ptr = domain.create_component_ptr<CMesh>("line");
CSimpleMeshGenerator::create_line(*mesh_ptr, 10. , p.get_option<Uint>("nb_cells"));
break;
case 2:
mesh_ptr = domain.create_component_ptr<CMesh>("square");
CSimpleMeshGenerator::create_rectangle(*mesh_ptr, 10. , 10. , p.get_option<Uint>("nb_cells"), p.get_option<Uint>("nb_cells"));
break;
default:
throw NotSupported(FromHere(),"Only 1D or 2D dimension supported");
}
CMesh& mesh = *mesh_ptr;
CFinfo << " Transforming mesh for finite volume: " << finite_volume_transformer.tree();
finite_volume_transformer.transform(mesh);
////////////////////////////////////////////////////////////////////////////////
// Create Solver / Discretization
////////////////////////////////////////////////////////////////////////////////
CFinfo << "Creating FiniteVolumeSolver" << CFendl;
FiniteVolumeSolver& solver = model.create_solver("CF.FVM.Core.FiniteVolumeSolver").as_type<FiniteVolumeSolver>();
solver.configure_option("physical_model",physics.uri());
solver.configure_option("domain",domain.uri());
solver.configure_option_recursively("ctime",model.as_type<CModelUnsteady>().time().uri());
solver.configure_option_recursively("time_accurate",true);
////////////////////////////////////////////////////////////////////////////////
// Initial condition
////////////////////////////////////////////////////////////////////////////////
CFinfo << "Setting initial condition" << CFendl;
CInitFieldFunction& init_solution = model.tools().create_component<CInitFieldFunction>("init_solution");
init_solution.configure_option("field",find_component_with_tag(mesh,"solution").uri());
const Real r_L = 4.696; const Real r_R = 1.408;
const Real p_L = 404400; const Real p_R = 101100;
const Real u_L = 0.; const Real u_R = 0.;
const Real v_L = 0.; const Real v_R = 0.;
const Real g=1.4;
if (physics.ndim() == 1)
{
RealVector3 left, right;
left << r_L , r_L*u_L , p_L/(g-1) + 0.5*r_L*u_L*u_L;
right << r_R , r_R*u_R , p_R/(g-1) + 0.5*r_R*u_R*u_R;
std::vector<std::string> function(3);
for (Uint i=0; i<function.size(); ++i)
function[i]="if(x<=5,"+to_str(left[i])+","+to_str(right[i])+")";
init_solution.configure_option("functions",function);
}
else if (physics.ndim() == 2)
{
RealVector4 left, right;
left << r_L , r_L*u_L , r_L*v_L, p_L/(g-1) + 0.5*r_L*(u_L*u_L+v_L*v_L);
right << r_R , r_R*u_R , r_R*v_R, p_R/(g-1) + 0.5*r_R*(u_R*u_R+v_R*v_R);
std::vector<std::string> function(4);
for (Uint i=0; i<function.size(); ++i)
function[i]="if(x<=5&y<=5,"+to_str(left[i])+","+to_str(right[i])+")";
init_solution.configure_option("functions",function);
}
else
throw NotSupported (FromHere(), "more than 2 dimensions not supported");
init_solution.transform(mesh);
////////////////////////////////////////////////////////////////////////////////
// Boundary conditions
////////////////////////////////////////////////////////////////////////////////
CFinfo << "Setting Reflective Boundary conditions" << CFendl;
if (physics.ndim() == 1)
{
solver.create_bc("inlet", find_component_recursively_with_name<CRegion>(mesh.topology(),"xneg"), "CF.FVM.Core.BCReflectCons1D");
solver.create_bc("outlet", find_component_recursively_with_name<CRegion>(mesh.topology(),"xpos"), "CF.FVM.Core.BCReflectCons1D");
}
else if (physics.ndim() == 2)
{
solver.create_bc("top", find_component_recursively_with_name<CRegion>(mesh.topology(),"top"), "CF.FVM.Core.BCReflectCons2D");
solver.create_bc("bottom",find_component_recursively_with_name<CRegion>(mesh.topology(),"bottom"),"CF.FVM.Core.BCReflectCons2D");
solver.create_bc("left", find_component_recursively_with_name<CRegion>(mesh.topology(),"left"), "CF.FVM.Core.BCReflectCons2D");
solver.create_bc("right", find_component_recursively_with_name<CRegion>(mesh.topology(),"right"), "CF.FVM.Core.BCReflectCons2D");
}
else
throw NotSupported (FromHere(), "more than 2 dimensions not supported");
////////////////////////////////////////////////////////////////////////////////
// Writer
////////////////////////////////////////////////////////////////////////////////
CMeshWriter::Ptr writer = build_component_abstract_type<CMeshWriter>("CF.Mesh.Gmsh.CWriter","mesh_writer");
model.tools().add_component(writer);
writer->configure_option("fields",std::vector<URI>(1,find_component_with_tag(mesh,"solution").uri()));
writer->configure_option("file",URI(model.name()+".msh"));
writer->configure_option("mesh",mesh.uri());
}
void CJournal::list_journal ( SignalArgs & args )
{
SignalFrame reply = args.create_reply( uri() );
copy_node(m_signals_map.content, reply.main_map.content);
}
