//in 固有値 evalue 高次元配置ベクトル Aij out 初期射影行列
void Agi::calprj(){
const int m = data->dim;
double f1[m], f2[m];
double distf1 = 0, distf2 = 0;
//二次元平面上への射影の場合
for (int i = 0; i < m; i++) {
if (i%2 == 0) {
f1[i] = pow(data->evalue[i],delta) ;// 固有値を代入 現在はとりあえず projection factor 0.5とする
f2[i] = 0;
distf1 = distf1 + pow(f1[i], 2);
} else {
f2[i] = pow(data->evalue[i],delta);
f1[i] = 0;
distf2 = distf2 + pow(f2[i], 2);
}
}
distf1 = sqrt(distf1);
distf2 = sqrt(distf2);
//射影行列確認
//stackのことを考えると vectorがいいが blas使うなら配列
for (int i =0; i< m; i++) {
ee.push_back(prj(f1[i]/distf1,f2[i]/distf2));
}
prjstack.push(ee);
}
void Parser::addProject(const ParserTreeItem::Ptr &item, const QStringList &fileList,
const QString &projectId)
{
// recalculate cache tree if needed
ParserTreeItem::Ptr prj(getCachedOrParseProjectTree(fileList, projectId));
if (item.isNull())
return;
// if there is an item - copy project tree to that item
item->copy(prj);
}
int main(int argc, char** argv) {
const double C = 3.;
const int N = 3;
snowgoose::ProjectToSimplex<double> prj(C);
auto check = [&N, &prj](double* x, const double* check) {
prj.project(N, x);
double d = snowgoose::VecUtils::vecDist(N, x, check);
std::cout << "x = " << snowgoose::VecUtils::vecPrint(N, x) << ", distance from reference = " << d << "\n";
SG_ASSERT(d < 0.001);
};
double x[N] = {4,4,0};
double r[N] = {1.5, 1.5, 0};
check(x, r);
return 0;
}
bool runCyberSL_CodeGen(const CyberComposition::SimulinkWrapper &slmodel, std::string cyber_file, Udm::DataNetwork* sdn_cyber, std::string directory)
{
//UdmDom::str_xsd_storage::RemoveXsd("CyberComposition.xsd");
//LINKS::Initialize();
//CyberComposition::Initialize(cyber_meta_diagram);
//
//// Collect Datanetwork to be passed to runCyPhy2SL_codeGen func
//Udm::DataNetwork * sdn_cyber = slmodel.__impl()->__getdn();
//// Generate Code
bool ret = true;
// Set the output directory
SFUtils::rootSFModel = slmodel;
std::string outputDirectory = directory;
std::string projectName;
if(!cyber_file.empty())
{
std::string inputFilename = cyber_file;
projectName = inputFilename.substr( 0, inputFilename.rfind( "." ) );
{
std::string::size_type lastSlashPos = projectName.rfind( "/" );
std::string::size_type lastBackslashPos = projectName.rfind( "\\" );
if ( lastSlashPos == std::string::npos ) lastSlashPos = lastBackslashPos;
if ( lastBackslashPos == std::string::npos ) lastBackslashPos = lastSlashPos;
std::string::size_type delimPos = std::min( lastSlashPos, lastBackslashPos );
if ( delimPos != std::string::npos ) projectName = projectName.substr( delimPos + 1 );
}
}
else
{
//Udm::Object sfparent = slmodel.parent();
//projectName = UdmUtil::ExtractName(sfparent);
projectName = slmodel.name();
}
//try {
// Open SLSF r
std::vector< Udm::StaticDataNetworkSpecifier> dnsvec;
Udm::StaticDataNetworkSpecifier sdns_cyphy("", sdn_cyber);
dnsvec.push_back( sdns_cyphy);
std::string slName = slmodel.name();
std::string slcFilename = outputDirectory + "/" + slName + "_SLC.xml";
UdmDom::DomDataNetwork &sdn_sfc = SFCUdmEngine::get_singleton().getDomDataNetwork();
sdn_sfc.CreateNew(slcFilename, "SFC.xsd", SFC::Project::meta );
Udm::StaticDataNetworkSpecifier sdns_SFC(slcFilename, &sdn_sfc);
dnsvec.push_back( sdns_SFC);
Udm::StaticUdmProject prj( dnsvec, Cyber2SLC::diagram);
Packets_t projects;
Packets_t rootDataflows;
SFC::Project rootSFC = SFC::Project::Cast(sdn_sfc.GetRootObject() );
rootSFC.name() = projectName;
projects.push_back( rootSFC);
rootDataflows.push_back(slmodel);
set<CyberComposition::Simulink::Subsystem> top_level_subs = slmodel.Simulink_Subsystem_kind_children();
for ( set<CyberComposition::Simulink::Subsystem>::iterator subIter = top_level_subs.begin(); subIter != top_level_subs.end(); subIter++ )
{
// Check for cycles in the graph before getting underway with the translation - throw an exception if a cycle is found
SFUtils::TopLevelTopologicalSort( *subIter );
}
printLog("******Start model transformation(SL_CodeGen) for SignalFlow model: "+(std::string)slmodel.name()+"******");
TL_0 tL_0;
tL_0(rootDataflows, projects);
if(SFUtils::getErrorReported())
{
ret = false;
printLog("******SL_CodeGen fails******");
}
else
{
printLog("******End model transformation(SL_CodeGen)******");
boost::filesystem::current_path( outputDirectory );
try{
CPrinter::print( rootSFC );
}
catch(udm_exception &e)
{
printLog(e.what());
prj.Close();
sdn_sfc.CloseWithUpdate();
return false;
}
boost::filesystem::current_path(outputDirectory);
//get the top subsystem name
set<CyberComposition::Simulink::Subsystem> subs = slmodel.Simulink_Subsystem_kind_children();
if(!subs.empty())
{
CyberComposition::Simulink::Subsystem topSub = *(subs.begin());
FMUCodeGen fmu(rootSFC, (std::string)topSub.name(), outputDirectory);
fmu.gen();
}
}
//get the top class name and args, generate fmi.xml and fmu.c files
prj.Close();
// Close SFC w
sdn_sfc.CloseWithUpdate();
if ( SFUtils::getPortTypeError() )
{
if(!boost::filesystem::remove( slcFilename ))
{
std::string err = "boost::filesystem::remove(\""+slcFilename+"\") fails";
throw std::exception(err.c_str());
}
}
return ret;
}
bool
PolygonReader::gridPointsInPolygon( std::vector<GridPointData> & pointsInPolygon, const GEOSGeom polygon )
{
/*
WdbProjectionPtr getWdbProjection(const std::string & def)
{
typedef std::map<std::string, WdbProjectionPtr> ProjectionMap;
static ProjectionMap projections;
ProjectionMap::iterator ret = projections.find(def);
if ( ret == projections.end() ) // not found
{
// ensure that cache does not grow to ridiculous size
if ( projections.size() > 512 )
projections.clear();
std::pair<ProjectionMap::iterator, bool> result =
projections.insert(std::make_pair(def, WdbProjectionPtr(new WdbProjection(def))));
ret = result.first;
}
return ret->second;
}
*/
BoundingBox bounds = getBounds( polygon );
//elog(DEBUG1, GEOSGeomToWKT(polygon) );
int startI = (bounds.left_ - reader_.placeSpecification().startX_) / reader_.placeSpecification().xIncrement_;
if (startI < 0) startI = 0;
int endI = ((bounds.right_ - reader_.placeSpecification().startX_) / reader_.placeSpecification().xIncrement_) + 1;
if (endI > reader_.placeSpecification().xNumber_) endI = reader_.placeSpecification().xNumber_;
int startJ = (bounds.bottom_ - reader_.placeSpecification().startY_) / reader_.placeSpecification().yIncrement_;
if (startJ < 0) startJ = 0;
int endJ = ((bounds.top_ - reader_.placeSpecification().startY_) / reader_.placeSpecification().yIncrement_) + 1;
if (endJ > reader_.placeSpecification().yNumber_) endJ = reader_.placeSpecification().yNumber_;
char res = 0;
GEOSCoordSequence * seq;
GEOSGeom point;
double x;
double y;
for (int j = startJ; j < endJ; j++ ) {
for (int i = startI; i < endI; i++) {
x = reader_.placeSpecification().startX_ + (i * reader_.placeSpecification().xIncrement_);
y = reader_.placeSpecification().startY_ + (j * reader_.placeSpecification().yIncrement_);
WdbProjection prj( reader_.placeSpecification().projDefinition_ );
if ( ! isMetric( reader_.placeSpecification().projDefinition_ ) ) {
x *= DEG_TO_RAD;
y *= DEG_TO_RAD;
}
prj.transformToDefault( 1, &x, &y );
if ( ! isMetric( DEFAULT_PROJECTION ) ) {
x *= RAD_TO_DEG;
y *= RAD_TO_DEG;
}
// Intersects
seq = GEOSCoordSeq_create(1, 2);
GEOSCoordSeq_setX(seq, 0, x);
GEOSCoordSeq_setY(seq, 0, y);
point = GEOSGeom_createPoint(seq);
//elog(DEBUG1, GEOSGeomToWKT(point) );
res = GEOS_DLL GEOSIntersects(polygon, point);
if (res == 1) {
GridPointData posPt;
posPt.x = i;
posPt.y = j;
pointsInPolygon.push_back(posPt);
}
GEOSGeom_destroy(point);
}
}
// Return
return ( pointsInPolygon.size() > 0 );
}
//射影の更新
//mdsの場合はこのままでも大丈夫 PCAの属性に対応すればOK
int Agi::refine(double* _pre, double* _new, int index) {
//まずはe3を求める
const int n = data->aginum;
const int m = data->dim;
double pi[m];
double powpinorm = 0;
//PCAで属性軸が選択されたとき
if(data->isPCA && index >= n){
int atrindex = index -n ;
for(int i = 0; i< m; i++){
pi[i] = data->getevector(atrindex,i);
powpinorm = pow(pi[i], 2)+powpinorm;
}
}
else{
for(int i = 0; i<m; i++){
pi[i] = data->getA(index, i);
powpinorm = pow(pi[i], 2)+powpinorm;
}
}
double pinorm = sqrt(powpinorm);
double powprenorm = pow(_pre[0], 2)+pow(_pre[1], 2);
double prenorm = sqrt(powprenorm);
double newnorm = sqrt(pow(_new[0], 2)+pow(_new[1], 2));
if(pinorm <= prenorm) {
std::cerr << "X error pinorm " << std::endl;
std::cerr << pinorm << std::endl;
std::cerr << "prenorm" << std::endl;
std::cerr << prenorm << std::endl;
return -1;
}
if (pinorm <= newnorm){
double gamma = 0.001;
if(newnorm > (1- gamma)*pinorm){
double _new2[2];
_new2[0] = (1-gamma) * pinorm * _new[0] / newnorm ;
_new2[1] = (1-gamma) * pinorm * _new[1] / newnorm ;
refine(_pre, _new2,index);
}
else {
std::cerr << "X2 error" << std::endl;
return -2;
}
}
double f3[m];
double f3norm = 0;
for(int i = 0; i<m; i++) {
f3[i] = pi[i] -_pre[0]*ee.at(i).first-_pre[1]*ee.at(i).second;
}
f3norm = sqrt(powpinorm- powprenorm );
for(int i = 0; i<m; i++){
f3[i] = f3[i]/f3norm;
}
//初期値設定
const int _N = 6;
double init[_N];
for (int i = 0; i < _N; i++) {
init[i] = ConstSolve2D::defaultInit[i];
}
// 後は制約式を解く
double* ans = solver2D( _pre, _new, f3norm, init);
double e1[m],e2[m];
double a3 = (_new[0] -_pre[0]*ans[0] -_pre[1]*ans[1])/f3norm;
double b3 = (_new[1] -_pre[0]*ans[2] -_pre[1]*ans[3])/f3norm;
for(int i = 0; i < m; i++){
double ei0 = ee.at(i).first;
double ei1 = ee.at(i).second;
e1[i] = ans[0] * ei0 + ans[1]* ei1 + a3 * f3[i];
e2[i] = ans[2] * ei0 + ans[3]* ei1 + b3 * f3[i];
}
ee.clear();
for(int i = 0; i < m; i++){
ee.push_back(prj(e1[i],e2[i]));
}
cal2Mtr();
return 0;
}
PolygonReader::BoundingBox
PolygonReader::getBounds( const GEOSGeom polygons )
{
BoundingBox ret;
int geomNumber = GEOSGetNumGeometries(polygons);
for (int n=0; n<geomNumber; n++) {
GEOSGeom outerRing;
if (geomNumber > 1) {
GEOSGeom polygon = const_cast<GEOSGeom>(GEOSGetGeometryN( polygons, n ));
if (polygon == NULL)
throw std::runtime_error( "Multigeometry returned is NULL" );
outerRing = const_cast<GEOSGeom>(GEOSGetExteriorRing( polygon ));
}
else {
outerRing = const_cast<GEOSGeom>(GEOSGetExteriorRing( polygons ));
}
if ( outerRing == NULL )
throw std::runtime_error( "Outer ring of polygon/shape is NULL." );
GEOSCoordSeq coordSeq = const_cast<GEOSCoordSeq>(GEOSGeom_getCoordSeq( outerRing ));
if ( coordSeq == NULL )
throw std::runtime_error( "Coordinate sequence of polygon/shape returned NULL" );
unsigned int size;
if ( GEOSCoordSeq_getSize( coordSeq, &size ) == 0 )
throw std::runtime_error( "Error when getting size of outer ring of polygon/shape" );
// Calculate Bounds
WdbProjection prj( reader_.placeSpecification().projDefinition_ );
lonlat coord;
// Initialize
GEOSCoordSeq_getX( coordSeq, 0, &coord.lon );
GEOSCoordSeq_getY( coordSeq, 0, &coord.lat );
if ( ! isMetric( DEFAULT_PROJECTION ) ) {
coord.lon *= DEG_TO_RAD;
coord.lat *= DEG_TO_RAD;
}
prj.transformFromDefault( 1, &coord.lon, &coord.lat );
if ( ! isMetric( reader_.placeSpecification().projDefinition_ ) ) {
coord.lon *= RAD_TO_DEG;
coord.lat *= RAD_TO_DEG;
}
if (n == 0) {
ret.left_ = coord.lon;
ret.top_ = coord.lat;
ret.right_ = coord.lon;
ret.bottom_ = coord.lat;
}
for ( unsigned int i = 1; i < size; i++ ) {
GEOSCoordSeq_getX( coordSeq, i, &coord.lon );
GEOSCoordSeq_getY( coordSeq, i, &coord.lat );
if ( ! isMetric( DEFAULT_PROJECTION ) ) {
coord.lon *= DEG_TO_RAD;
coord.lat *= DEG_TO_RAD;
}
prj.transformFromDefault( 1, &coord.lon, &coord.lat );
if ( ! isMetric( reader_.placeSpecification().projDefinition_ ) ) {
coord.lon *= RAD_TO_DEG;
coord.lat *= RAD_TO_DEG;
}
if (coord.lon < ret.left_)
ret.left_ = coord.lon;
else
if (coord.lon > ret.right_)
ret.right_ = coord.lon;
if (coord.lat < ret.bottom_)
ret.bottom_ = coord.lat;
else
if (coord.lat > ret.top_ )
ret.top_ = coord.lat;
}
}
return ret;
}
StelProjectorP StelCore::getProjection2d() const
{
StelProjectorP prj(new StelProjector2d());
prj->init(currentProjectorParams);
return prj;
}
//---------------------------------------------------------
inline void CVIEW_Map_Control::_Set_StatusBar(CSG_Point ptWorld)
{
static bool bBuisy = false;
if( bBuisy == false )
{
bBuisy = true;
CSG_Tool *pProjector = NULL;
if( m_pMap->Get_Parameter("GCS_POSITION")->asBool() && m_pMap->Get_Projection().is_Okay() && (pProjector = SG_Get_Tool_Library_Manager().Get_Tool("pj_proj4", 2)) != NULL ) // Coordinate Transformation (Shapes)
{
if( pProjector->is_Executing() )
{
pProjector = NULL;
}
else
{
SG_UI_Progress_Lock(true);
SG_UI_Msg_Lock (true);
CSG_Shapes prj(SHAPE_TYPE_Point), gcs(SHAPE_TYPE_Point); prj.Add_Shape()->Add_Point(ptWorld); prj.Get_Projection().Assign(m_pMap->Get_Projection());
pProjector->Settings_Push(NULL);
if( pProjector->Set_Parameter("CRS_PROJ4", SG_T("+proj=longlat +ellps=WGS84 +datum=WGS84"))
&& pProjector->Set_Parameter("SOURCE" , &prj)
&& pProjector->Set_Parameter("TARGET" , &gcs)
&& pProjector->Execute() )
{
CSG_Point ptWorld_gcs = gcs.Get_Shape(0)->Get_Point(0);
STATUSBAR_Set_Text(wxString::Format("X %s", SG_Double_To_Degree(ptWorld_gcs.Get_X()).c_str()), STATUSBAR_VIEW_X);
STATUSBAR_Set_Text(wxString::Format("Y %s", SG_Double_To_Degree(ptWorld_gcs.Get_Y()).c_str()), STATUSBAR_VIEW_Y);
pProjector->Settings_Pop();
}
else
{
pProjector->Settings_Pop(); pProjector = NULL;
}
SG_UI_Progress_Lock(false);
SG_UI_Msg_Lock (false);
}
}
if( !pProjector )
{
STATUSBAR_Set_Text(wxString::Format("X %f", ptWorld.Get_X()), STATUSBAR_VIEW_X);
STATUSBAR_Set_Text(wxString::Format("Y %f", ptWorld.Get_Y()), STATUSBAR_VIEW_Y);
}
if( m_Mode == MAP_MODE_DISTANCE )
{
STATUSBAR_Set_Text(wxString::Format("D %f", m_Distance + m_Distance_Move), STATUSBAR_VIEW_Z);
}
else if( Get_Active_Layer() )
{
STATUSBAR_Set_Text(wxString::Format("Z %s", Get_Active_Layer()->Get_Value(ptWorld, _Get_World(2.0)).c_str()), STATUSBAR_VIEW_Z);
}
else
{
STATUSBAR_Set_Text("Z", STATUSBAR_VIEW_Z);
}
bBuisy = false;
}
}
int main()
{
QFile prj(":prj/barracks-scaled11-elements.prj");
bool ignoreSystemZones = true;
bool ignoreAmbientZone = true;
std::cout << "Opening file... ";
if(!prj.open(QFile::ReadOnly))
{
std::cout << " failed." << std::endl;
return EXIT_FAILURE;
}
std::cout << " succeeded." << std::endl << std::endl;
QTextStream stream(&prj);
prj::Reader input(&stream);
prj::Model airflowModel(input);
std::cout << "CONTAM version: " + airflowModel.version() << std::endl;
std::cout << "SketchPad dimensions: " << airflowModel.skwidth() << " cells by "
<< airflowModel.skheight() << " cells" << std::endl;
std::cout << "SketchPad scale: " << TO_STRING(airflowModel.scale()) << " m" <<std::endl;
std::cout << "SketchPad scale: " << TO_STRING(airflowModel.scale()) << " m" <<std::endl;
std::cout << "Active contaminants: " << airflowModel.contaminants().size() << std::endl;
for(unsigned int i=0;i<airflowModel.contaminants().size();i++)
{
int nr = airflowModel.contaminants()[i];
std::cout << '\t' << nr << ": " << airflowModel.species()[nr-1].name() << std::endl;
}
std::cout << std::endl << "Day schedules: " << airflowModel.daySchedules().size()
<< std::endl;
std::cout << std::endl << "Week schedules: " << airflowModel.weekSchedules().size()
<< std::endl;
std::cout << std::endl << "Wind pressure profiles: "
<< airflowModel.windPressureProfiles().size()
<< std::endl;
for(unsigned int i=1;i<=airflowModel.windPressureProfiles().size();i++)
{
std::cout << '\t' << i << ": " << airflowModel.windPressureProfiles()[i-1].name()
<< std::endl;
}
VECTOR<prj::Path> paths = airflowModel.paths();
std::cout << std::endl << "Paths: " << paths.size() << std::endl;
QFile fp("prj.dot");
if (fp.open(QFile::WriteOnly))
{
QTextStream stream(&fp);
stream << "graph {\n";
for(unsigned int i=0;i<paths.size();i++)
{
int pzm = paths[i].pzm();
int pzn = paths[i].pzn();
if(pzm<0)
{
if(ignoreAmbientZone)
{
continue;
}
pzm=0;
}
if(ignoreSystemZones && airflowModel.zones()[pzm-1].system())
{
continue;
}
if(pzn<0)
{
if(ignoreAmbientZone)
{
continue;
}
pzn=0;
}
if(ignoreSystemZones && airflowModel.zones()[pzn-1].system())
{
continue;
}
stream << pzn << " -- " << pzm << '\n';
}
stream << "}";
}
fp.close();
/*
VECTOR<prj::CvfDat> cvf = airflowModel.getCvfDat();
std::cout << std::endl << "CvfDat elements: " << cvf.size() << std::endl;
for(unsigned int i=0;i<cvf.size();i++)
{
std::cout << '\t' << i+1 << ": " << cvf[i].name() << std::endl;
}
std::cout << std::endl << "Simple air handling systems: "
<< airflowModel.ahs().size()
<< std::endl;
for(unsigned int i=1;i<=airflowModel.ahs().size();i++)
{
std::cout << '\t' << i << ": " << airflowModel.ahs()[i-1].name()
<< std::endl;
}
VECTOR<prj::Zone> zones = airflowModel.zones();
std::cout << std::endl << "Zones: " << zones.size() << std::endl;
for(unsigned int i=0;i<zones.size();i++)
{
std::cout << '\t' << i+1 << ": " << zones[i].name() << std::endl;
}
*/
std::cout << std::endl << "Done." << std::endl;
//std::cout << airflowModel.toString();
//prj::PlrTest1 plr;
//plr.setName("TEST");
//airflowModel.addAirflowElement(plr);
/*
QFile fp("out.prj");
if (fp.open(QFile::WriteOnly))
{
QTextStream stream(&fp);
stream << QString().fromStdString(airflowModel.toString());
fp.close();
}
else
{
std::cout << "Failed to write 'out.prj'" << std::endl;
return EXIT_FAILURE;
}
*/
return EXIT_SUCCESS;
}
int main( int argc, char* argv[] ) {
// Try to process the command line
if ( !ConfigKeeper::getSingleton().processCommandLineArguments( argc, argv ) ) {
std::cout << ConfigKeeper::getSingleton().getDescription();
return 0;
}
// See if help was requested
if ( ConfigKeeper::getSingleton().getCount( "help" ) ) {
std::cout << ConfigKeeper::getSingleton().getDescription();
return 0;
}
// Make sure an input was specified
if ( !ConfigKeeper::getSingleton().getCount( "slsf-file" ) ) {
std::cerr << "Input file must be specified." << std::endl;
std::cerr << ConfigKeeper::getSingleton().getDescription();
return 1;
}
// Set the generation language
bool generateC = true;
if ( ConfigKeeper::getSingleton().getCount( "java" ) ) generateC = false;
if ( ConfigKeeper::getSingleton().getCount( "c" ) ) generateC = true;
bool annotations = ConfigKeeper::getSingleton().getCount( "annotations" );
// Set the output directory
std::string outputDirectory;
if ( ConfigKeeper::getSingleton().getCount( "output-directory" ) ) {
outputDirectory = ConfigKeeper::getSingleton().getStringValue( "output-directory" );
}
DirectoryVector directoryVector;
if ( ConfigKeeper::getSingleton().getCount( "libdir" ) ) {
directoryVector = ConfigKeeper::getSingleton().getStringVector( "libdir" );
}
addMFileDirectories( directoryVector );
// Determine the input file name
std::string inputFilename = ConfigKeeper::getSingleton().getStringValue( "slsf-file" );
std::string projectName = inputFilename.substr( 0, inputFilename.rfind( "." ) );
{
std::string::size_type lastSlashPos = projectName.rfind( "/" );
std::string::size_type lastBackslashPos = projectName.rfind( "\\" );
if ( lastSlashPos == std::string::npos ) lastSlashPos = lastBackslashPos;
if ( lastBackslashPos == std::string::npos ) lastBackslashPos = lastSlashPos;
std::string::size_type delimPos = std::min( lastSlashPos, lastBackslashPos );
if ( delimPos != std::string::npos ) projectName = projectName.substr( delimPos + 1 );
}
std::string arg1 = SLSF_PARADIGM_NAME " = \"" + inputFilename + "\" ";
// std::string arg2 = "SFC = \"" + std::string(argv[2]) + string(".xml") + "\" !\"SFC.xsd\" ";
InputFileRegistry ifr;
ifr.registerFile( arg1 );
try {
// Open SLSF r
Udm::SmartDataNetwork sdnSLSF_fb0( SLSF::diagram );
sdnSLSF_fb0.OpenExisting(
ifr.getFileName( SLSF_PARADIGM_NAME ),
UseXSD()( ifr.getFileName( SLSF_PARADIGM_NAME ) ) ? ifr.getXsdName( SLSF_PARADIGM_NAME ) : SLSF_PARADIGM_NAME,
Udm::CHANGES_LOST_DEFAULT
);
Udm::StaticDataNetworkSpecifier sdns_SLSF_fb1( ifr.getFileName( SLSF_PARADIGM_NAME ), &sdnSLSF_fb0 );
ModelsFolderMap modelsFolderMap = getModelsFolderMap( sdnSLSF_fb0 );
for( ModelsFolderMap::iterator mfmItr = modelsFolderMap.begin() ; mfmItr != modelsFolderMap.end() ; ++mfmItr ) {
int modelsFolderID = mfmItr->first;
std::string modelsFolderName = mfmItr->second.name();
if ( outputDirectory.empty() ) outputDirectory = modelsFolderName;
std::vector< Udm::StaticDataNetworkSpecifier > dnsvec;
dnsvec.push_back( sdns_SLSF_fb1 );
if ( !boost::filesystem::create_directories( outputDirectory ) ) {
if ( !boost::filesystem::is_directory( outputDirectory ) ) {
std::cerr << "ERROR: Could not create \"" + outputDirectory + "\" directory." << std::endl;
continue;
}
}
std::string sfcFilename = outputDirectory + "/" + modelsFolderName + "_SFC.xml";
std::string arg2= "SFC = \"" + sfcFilename + "\" !\"SFC.xsd\" ";
ifr.registerFile( arg2 );
// Open SFC w
UdmDom::DomDataNetwork &sdnSFC_fb3 = SFCUdmEngine::get_singleton().getDomDataNetwork();
sdnSFC_fb3.CreateNew(
ifr.getFileName( "SFC" ),
UseXSD()( ifr.getFileName( "SFC" ) ) ? ifr.getXsdName( "SFC" ) : "SFC",
SFC::Project::meta,
Udm::CHANGES_LOST_DEFAULT
);
Udm::StaticDataNetworkSpecifier sdns_SFC_fb4( ifr.getFileName( "SFC" ), &sdnSFC_fb3 );
dnsvec.push_back( sdns_SFC_fb4 );
// Create the project
Udm::StaticUdmProject prj( dnsvec, ESM2SLC::diagram );
Udm::DataNetwork& SLSF_ref_fb2= prj.GetDataNetwork( ifr.getFileName( SLSF_PARADIGM_NAME ) );
Udm::DataNetwork& sFC_ref_fb5= prj.GetDataNetwork( ifr.getFileName( "SFC" ) );
Packets_t projects_1;
Packets_t rootDataflows_3;
// get objects from DNs
ModelsFolderMap modelsFolderMap2 = getModelsFolderMap( SLSF_ref_fb2 );
ModelsFolderMap::iterator mfmItr2 = modelsFolderMap2.find( modelsFolderID );
if ( mfmItr2 == modelsFolderMap2.end() ) {
std::cerr << "ERROR: Could not find ModelsFolder with id \"" << modelsFolderID << "\"" << std::endl;
} else {
SLSF::Dataflow dataflow = getDataflow( mfmItr2->second );
rootDataflows_3.push_back( dataflow );
// Get access to temporary root object(s).
// transformation
SFC::Project rootSFC_257f = SFC::Project::Cast( sFC_ref_fb5.GetRootObject() );
rootSFC_257f.name() = projectName;
projects_1.push_back( rootSFC_257f );
for( Packets_t::const_iterator it = rootDataflows_3.begin() ; it != rootDataflows_3.end() ; ++it ) {
Packets_t oneRootState;
oneRootState.push_back( *it );
TransClass tL_0;
// tL_0( projects_1, oneRootState);
tL_0( oneRootState, projects_1 );
// rootSFC_257f.numInstance() = ni>0 ? ni : 1;
boost::filesystem::path path = boost::filesystem::current_path();
boost::filesystem::current_path( outputDirectory );
if ( generateC ) CPrinter::print( rootSFC_257f );
else JPrinter::printProject( rootSFC_257f, annotations );
boost::filesystem::current_path( path );
// Print the S-Function wrapper
// printSFuncWrapper( SFUtils::convertToCPlusPlusName( stateName ), rootSFC_257f );
// Delete program
}
}
// Close the project
prj.Close();
// Close SFC w
sdnSFC_fb3.CloseWithUpdate();
if ( SFUtils::getPortTypeError() ) boost::filesystem::remove( sfcFilename );
}
modelsFolderMap.clear();
// Close SLSF r
sdnSLSF_fb0.CloseNoUpdate();
} catch( udm_exception &e ) {
cout << e.what() << endl;
return 2;
} catch( std::exception &e ) {
std::cout << e.what() << std::endl;
return 3;
} catch( ... ) {
std::cout << "Unknown exception (sorry)" << std::endl;
return 4;
}
if ( CodeGenerator::getSingleton().getError() ) return 5;
return 0;
}
