void appendToDataFiles()
{
if (!m_OKToGo)
return;
openfluid::core::SpatialUnit* UU;
// write data files
for (std::list<KmlSerieInfo>::iterator it=m_KmlSeriesInfos.begin();it!=m_KmlSeriesInfos.end();++it)
{
for (std::map<openfluid::core::UnitID_t,KmlUnitInfoExtra>::iterator it2=(*it).UnitsInfos.begin();
it2!=(*it).UnitsInfos.end();
++it2)
{
if ((*it2).second.IsPlotted)
{
UU = OPENFLUID_GetUnit((*it).UnitsClass,(*it2).second.UnitID);
if (UU != nullptr)
{
(*((*it2).second.DataFile)) << OPENFLUID_GetCurrentDate().getAsString("%Y%m%d-%H%M%S");
for (std::vector<openfluid::core::VariableName_t>::iterator it3 = (*it).VarsList.begin();
it3 != (*it).VarsList.end();
++it3)
{
if (OPENFLUID_IsVariableExist(UU,*it3,OPENFLUID_GetCurrentTimeIndex(),openfluid::core::Value::DOUBLE))
{
double Val;
OPENFLUID_GetVariable(UU,*it3,OPENFLUID_GetCurrentTimeIndex(),Val);
(*((*it2).second.DataFile)) << ";" << Val;
}
}
(*((*it2).second.DataFile)) << "\n";
}
else
{
(*((*it2).second.DataFile)) << OPENFLUID_GetCurrentDate().getAsString("%Y%m%d-%H%M%S") << ";n/a\n";
}
}
}
}
}
void WriteDataToFiles()
{
std::map<std::string, SerieInfo>::iterator Sit;
std::map<std::string, SerieInfo>::iterator Sitb = m_Series.begin();
std::map<std::string, SerieInfo>::iterator Site = m_Series.end();
for (Sit = Sitb; Sit != Site; ++Sit)
{
if ((*Sit).second.Type == SerieInfo::SERIE_VAR)
{
openfluid::core::Value* Val =
(*Sit).second.Unit->variables()->currentValueIfIndex((*Sit).second.VarName,
OPENFLUID_GetCurrentTimeIndex());
if (Val!= NULL)
{
*((*Sit).second.FileHandle) << OPENFLUID_GetCurrentDate().getAsString("%Y-%m-%dT%H:%M:%S");
*((*Sit).second.FileHandle) << " ";
if (Val->isSimple() && !Val->isStringValue())
Val->writeToStream(*((*Sit).second.FileHandle));
else
*((*Sit).second.FileHandle) << "NaN";
*((*Sit).second.FileHandle) << "\n";
}
}
}
}
void onStepCompleted()
{
if (m_EveryTime)
{
std::ostringstream oss;
oss << OPENFLUID_GetCurrentTimeIndex();
ExportUnitsGraphAsDotFile(m_BaseFileName + "_t" + oss.str() + ".dot","at t="+oss.str());
}
}
openfluid::base::SchedulingRequest runStep()
{ std::cout << "sim.a " << OPENFLUID_GetCurrentTimeIndex() << std::endl; return DefaultDeltaT(); }
void onStepCompleted()
{
std::cout << "Hopla observer : onStepCompleted() at index " << OPENFLUID_GetCurrentTimeIndex() << std::endl;
}
void processSerie(GeoVectorSerie& Serie)
{
QString IndexStr = "init";
openfluid::base::SimulationStatus::SimulationStage CurrentStage =
OPENFLUID_GetCurrentStage();
bool OKToWrite = false;
if (CurrentStage == openfluid::base::SimulationStatus::INITIALIZERUN)
{
OKToWrite = Serie.WhenMode == GeoVectorSerie::WHENINIT ||
Serie.WhenMode == GeoVectorSerie::WHENCONTINUOUS;
}
else if (CurrentStage == openfluid::base::SimulationStatus::RUNSTEP)
{
if (Serie.WhenMode == GeoVectorSerie::WHENCONTINUOUS)
{
openfluid::core::TimeIndex_t CurrentIndex = OPENFLUID_GetCurrentTimeIndex();
IndexStr = QString("%1").arg(CurrentIndex);
if (Serie.LatestContinuousIndex + Serie.WhenContinuousDelay < CurrentIndex)
{
OKToWrite = true;
Serie.LatestContinuousIndex = CurrentIndex;
}
}
}
else if (CurrentStage == openfluid::base::SimulationStatus::FINALIZERUN)
{
IndexStr = "final";
OKToWrite = Serie.WhenMode == GeoVectorSerie::WHENCONTINUOUS ||
Serie.WhenMode == GeoVectorSerie::WHENFINAL;
}
else
{
OPENFLUID_LogWarning("Internal stage error when processing geographic series");
return;
}
if (OKToWrite)
{
std::string FullFilePath =
m_OutputPath + "/" + QString(QString::fromStdString(Serie.OutfilePattern).arg(IndexStr)).toStdString();
GDALDriver_COMPAT* Driver = GDALGetDriverByName_COMPAT(m_GDALFormat.c_str());
if (openfluid::tools::Filesystem::isFile(FullFilePath))
{
// deletion of an existing file or files set
GDALDelete_COMPAT(Driver,FullFilePath.c_str());
}
GDALDataset_COMPAT* CreatedFile = GDALCreate_COMPAT(Driver,FullFilePath.c_str());
std::string CreatedLayerName = QFileInfo(QString::fromStdString(FullFilePath)).completeBaseName().toStdString();
OGRLayer* CreatedLayer = CreatedFile->CreateLayer(CreatedLayerName.c_str(),nullptr,
Serie.GeoLayer->GetLayerDefn()->GetGeomType(),
nullptr);
OGRFieldDefn IDField("OFLD_ID",OFTInteger);
CreatedLayer->CreateField(&IDField);
GeoVectorSerie::VariablesSet_t::const_iterator itV;
GeoVectorSerie::VariablesSet_t::const_iterator itVb = Serie.VariablesSet.begin();
GeoVectorSerie::VariablesSet_t::const_iterator itVe = Serie.VariablesSet.end();
for (itV = itVb; itV != itVe; ++itV)
{
std::string FieldName = (*itV).second;
OGRFieldDefn VarField(FieldName.c_str(),OFTReal);
VarField.SetWidth(24);
VarField.SetPrecision(15);
CreatedLayer->CreateField(&VarField);
}
OGRFeature* SourceFeature;
openfluid::core::SpatialUnit* UU;
Serie.GeoLayer->ResetReading();
while ((SourceFeature = Serie.GeoLayer->GetNextFeature()) != nullptr)
{
int SourceID = SourceFeature->GetFieldAsInteger(Serie.OFLDIDFieldIndex);
UU = OPENFLUID_GetUnit(Serie.UnitsClass,SourceID);
if (UU)
{
CreatedLayer->GetLayerDefn();
OGRFeature* CreatedFeature = OGRFeature::CreateFeature(CreatedLayer->GetLayerDefn());
CreatedFeature->SetGeometry(SourceFeature->GetGeometryRef()->clone());
CreatedFeature->SetField("OFLD_ID",SourceID);
for (itV = itVb; itV != itVe; ++itV)
{
std::string VarName = (*itV).first;
std::string FieldName = (*itV).second;
openfluid::core::DoubleValue CreatedValue = 0.0;
bool IsValueCreated = false;
if (FieldName.empty())
FieldName = VarName;
openfluid::core::IndexedValue VarValue;
if (OPENFLUID_IsVariableExist(UU,VarName))
{
OPENFLUID_GetLatestVariable(UU,VarName,VarValue);
if (VarValue.value()->isDoubleValue()) // OpenFLUID value is double
{
CreatedValue = VarValue.value()->asDoubleValue();
IsValueCreated = true;
}
else if (VarValue.value()->convert(CreatedValue)) // OpenFLUID value can be converted to double
{
IsValueCreated = true;
}
else
{
QString Msg = QString("Variable %1 on unit %2#%3 is not a double or a compatible type")
.arg(VarName.c_str()).arg(UU->getClass().c_str()).arg(UU->getID());
OPENFLUID_LogWarning(Msg.toStdString());
}
}
else
{
QString Msg = QString("Variable %1 does not exist on unit %2#%3")
.arg(VarName.c_str()).arg(UU->getClass().c_str()).arg(UU->getID());
OPENFLUID_LogWarning(Msg.toStdString());
}
if (IsValueCreated) // OpenFLUID value is written to GIS file only if it is double or converted to double
CreatedFeature->SetField(FieldName.c_str(),CreatedValue);
}
if (CreatedLayer->CreateFeature(CreatedFeature) != OGRERR_NONE)
{
QString Msg = QString("Feature for unit %1#%2 cannot be created")
.arg(UU->getClass().c_str()).arg(UU->getID());
OPENFLUID_LogWarning(Msg.toStdString());
}
OGRFeature::DestroyFeature(CreatedFeature);
}
}
GDALClose_COMPAT(CreatedFile);
}
}
