X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROData%2FHYDROData_CalculationCase.cxx;h=2dd84bef4672b2a3a2f18bf2c900456278ebb7f7;hb=f9bd5128a1aed8c1974b1d1cfb87aff32191fa60;hp=d878012a0648cbfb234971188654c6db0cf66a92;hpb=e989e0f3cdd230307b28ed0128a49978b27096ef;p=modules%2Fhydro.git diff --git a/src/HYDROData/HYDROData_CalculationCase.cxx b/src/HYDROData/HYDROData_CalculationCase.cxx index d878012a..2dd84bef 100644 --- a/src/HYDROData/HYDROData_CalculationCase.cxx +++ b/src/HYDROData/HYDROData_CalculationCase.cxx @@ -1,3 +1,20 @@ +// Copyright (C) 2014-2015 EDF-R&D +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// #include "HYDROData_CalculationCase.h" @@ -8,9 +25,12 @@ #include "HYDROData_Iterator.h" #include "HYDROData_NaturalObject.h" #include "HYDROData_PolylineXY.h" +#include "HYDROData_StricklerTable.h" +#include "HYDROData_LandCover.h" #include "HYDROData_SplittedShapesGroup.h" #include "HYDROData_Region.h" #include "HYDROData_Tool.h" +#include "HYDROData_GeomTool.h" #include @@ -31,6 +51,7 @@ #include #include #include +#include //#define DEB_CALCULATION 1 #ifdef DEB_CALCULATION @@ -47,6 +68,12 @@ #define EXPORT_NAME "HYDRO_" + GetName() +#include +#include + +#define _DEVDEBUG_ +#include "HYDRO_trace.hxx" + IMPLEMENT_STANDARD_HANDLE(HYDROData_CalculationCase, HYDROData_Entity) IMPLEMENT_STANDARD_RTTIEXT(HYDROData_CalculationCase, HYDROData_Entity) @@ -109,9 +136,14 @@ void HYDROData_CalculationCase::SetName( const QString& theName ) QStringList HYDROData_CalculationCase::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const { QStringList aResList = dumpObjectCreation( theTreatedObjects ); + aResList.prepend( "# Calculation case" ); QString aCalculName = GetObjPyName(); + AssignmentMode aMode = GetAssignmentMode(); + QString aModeStr = aMode==MANUAL ? "HYDROData_CalculationCase.MANUAL" : "HYDROData_CalculationCase.AUTOMATIC"; + aResList << QString( "%0.SetAssignmentMode( %1 )" ).arg( aCalculName ).arg( aModeStr ); + HYDROData_SequenceOfObjects aGeomObjects = GetGeometryObjects(); HYDROData_SequenceOfObjects::Iterator anIter( aGeomObjects ); for ( ; anIter.More(); anIter.Next() ) @@ -144,44 +176,96 @@ QStringList HYDROData_CalculationCase::DumpToPython( MapOfTreatedObjects& theTre aResList << QString( "%1.AddGeometryGroup( %2 );" ).arg( aCalculName ).arg( aGroupName ); } - aResList << QString( "" ); Handle(HYDROData_PolylineXY) aBoundaryPolyline = GetBoundaryPolyline(); setPythonReferenceObject( theTreatedObjects, aResList, aBoundaryPolyline, "SetBoundaryPolyline" ); - aResList << QString( "" ); - aResList << QString( "%1.Update();" ).arg( aCalculName ); + if( aMode==AUTOMATIC ) + DumpRulesToPython( aCalculName, aResList ); + aResList << QString( "" ); + aResList << "# Start the algorithm of the partition and assignment"; + aResList << QString( "%1.Update();" ).arg( aCalculName ); - // Now we restore the regions and zones order - HYDROData_SequenceOfObjects aRegions = GetRegions(); - anIter.Init( aRegions ); - for ( ; anIter.More(); anIter.Next() ) + if( aMode==MANUAL ) { - Handle(HYDROData_Region) aRegion = - Handle(HYDROData_Region)::DownCast( anIter.Value() ); - if ( aRegion.IsNull() ) - continue; - - QString aRegionName = aRegion->GetName(); - - HYDROData_SequenceOfObjects aZones = aRegion->GetZones(); - HYDROData_SequenceOfObjects::Iterator aZonesIter( aZones ); - for ( ; aZonesIter.More(); aZonesIter.Next() ) + // Now we restore the regions and zones order + HYDROData_SequenceOfObjects aRegions = GetRegions(); + anIter.Init( aRegions ); + for ( ; anIter.More(); anIter.Next() ) { - Handle(HYDROData_Zone) aRegZone = - Handle(HYDROData_Zone)::DownCast( aZonesIter.Value() ); - if ( aRegZone.IsNull() ) + Handle(HYDROData_Region) aRegion = + Handle(HYDROData_Region)::DownCast( anIter.Value() ); + if ( aRegion.IsNull() ) continue; - // TODO + theTreatedObjects.insert( aRegion->GetName(), aRegion ); + QStringList aRegDump = aRegion->DumpToPython( theTreatedObjects ); + aResList << aRegDump; } } + + // Export calculation case aResList << QString( "" ); + aResList << "# Export of the calculation case"; + QString aStudyName = "theStudy"; + QString anEntryVar = aCalculName + "_entry"; + aResList << QString( "%1 = %2.Export( %3._get_StudyId() )" ).arg( anEntryVar ).arg( aCalculName ).arg( aStudyName ); + + // Get geometry object and print debug information + aResList << ""; + aResList << "# Get geometry shape and print debug information"; + aResList << "import GEOM"; + aResList << QString( "print \"Entry:\", %1" ).arg( anEntryVar ); + QString aGeomShapeName = aCalculName + "_geom"; + aResList << QString( "%1 = salome.IDToObject( str( %2 ) )" ).arg( aGeomShapeName ).arg( anEntryVar ); + aResList << QString( "print \"Geom shape:\", %1" ).arg( aGeomShapeName ); + aResList << QString( "print \"Geom shape name:\", %1.GetName()" ).arg( aGeomShapeName ); + + DumpSampleMeshing( aResList, aStudyName, aGeomShapeName, aCalculName+"_mesh" ); + aResList << QString( "" ); return aResList; } +void HYDROData_CalculationCase::DumpSampleMeshing( QStringList& theResList, + const QString& theStudyName, + const QString& theGeomShapeName, + const QString& theMeshName ) const +{ + theResList << ""; + theResList << "# Meshing"; + theResList << "import SMESH, SALOMEDS"; + theResList << "from salome.smesh import smeshBuilder"; + theResList << "from salome.geom import geomBuilder"; + + theResList << QString( "smesh = smeshBuilder.New( %1 )" ).arg( theStudyName ); + theResList << QString( "%1 = smesh.Mesh( %2 )" ).arg( theMeshName ).arg( theGeomShapeName ); + theResList << QString( "MEFISTO_2D = %1.Triangle( algo=smeshBuilder.MEFISTO )" ).arg( theMeshName ); + theResList << "Max_Element_Area_1 = MEFISTO_2D.MaxElementArea( 10 )"; + theResList << QString( "Regular_1D = %1.Segment()" ).arg( theMeshName ); + theResList << "Max_Size_1 = Regular_1D.MaxSize(10)"; + theResList << QString( "isDone = %1.Compute()" ).arg( theMeshName ); + + theResList << ""; + theResList << "# Set names of Mesh objects"; + theResList << "smesh.SetName( MEFISTO_2D.GetAlgorithm(), 'MEFISTO_2D' )"; + theResList << "smesh.SetName( Regular_1D.GetAlgorithm(), 'Regular_1D' )"; + theResList << "smesh.SetName( Max_Size_1, 'Max Size_1' )"; + theResList << "smesh.SetName( Max_Element_Area_1, 'Max. Element Area_1' )"; + theResList << QString( "smesh.SetName( %1.GetMesh(), '%1' )" ).arg( theMeshName ); + + theResList << ""; + theResList << "# Greate SMESH groups"; + theResList << QString( "geompy = geomBuilder.New( %1 )" ).arg( theStudyName ); + theResList << QString( "geom_groups = geompy.GetGroups( %1 )" ).arg( theGeomShapeName ); + theResList << QString( "for group in geom_groups:" ); + theResList << QString( " smesh_group = %1.GroupOnGeom(group, group.GetName(), SMESH.EDGE)" ) + .arg( theMeshName ); + theResList << QString( " smesh.SetName(smesh_group, group.GetName())" ); + theResList << QString( " print \"SMESH group '%s': %s\" % (smesh_group.GetName(), smesh_group)" ); +} + HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetAllReferenceObjects() const { HYDROData_SequenceOfObjects aResSeq = HYDROData_Entity::GetAllReferenceObjects(); @@ -199,6 +283,7 @@ HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetAllReferenceObjects() void HYDROData_CalculationCase::Update() { HYDROData_Entity::Update(); + SetWarning(); // At first we remove previously created objects RemoveRegions(); @@ -232,8 +317,15 @@ void HYDROData_CalculationCase::Update() anEdgesList.append( aSplitData ); } - //CreateRegionsDef( aDocument, aZonesList ); - CreateRegionsAuto( aDocument, aZonesList ); + switch( GetAssignmentMode() ) + { + case MANUAL: + CreateRegionsDef( aDocument, aZonesList ); + break; + case AUTOMATIC: + CreateRegionsAuto( aDocument, aZonesList ); + break; + } CreateEdgeGroupsDef( aDocument, anEdgesList ); } @@ -260,8 +352,9 @@ void HYDROData_CalculationCase::CreateRegionsAuto( const Handle(HYDROData_Docume const HYDROData_SplitToZonesTool::SplitDataList& theZones ) { QMap aRegionsMap; //object name to region + QMap aRegionNameToObjNameMap; QString aZonesPref = CALCULATION_ZONES_PREF; - HYDROData_PriorityQueue aPr( this ); + HYDROData_PriorityQueue aPr( this, DataTag_CustomRules ); // 1. First we create a default region for each object included into the calculation case HYDROData_SequenceOfObjects aGeomObjects = GetGeometryObjects(); @@ -274,6 +367,7 @@ void HYDROData_CalculationCase::CreateRegionsAuto( const Handle(HYDROData_Docume QString aRegName = anObjName + "_reg"; Handle(HYDROData_Region) aRegion = addNewRegion( theDoc, aRegName, false ); aRegionsMap.insert( anObjName, aRegion ); + aRegionNameToObjNameMap.insert( aRegName, anObjName ); } // 2. Now for each zone it is necessary to determine the most priority object @@ -283,13 +377,20 @@ void HYDROData_CalculationCase::CreateRegionsAuto( const Handle(HYDROData_Docume { const HYDROData_SplitToZonesTool::SplitData& aSplitData = anIter.next(); HYDROData_Zone::MergeAltitudesType aMergeType; - Handle(HYDROData_Object) aRegObj = aPr.GetMostPriorityObject( aSplitData.ObjectNames, aMergeType ); + Handle(HYDROData_Object) aRegObj = + Handle(HYDROData_Object)::DownCast( aPr.GetMostPriorityObject( aSplitData.ObjectNames, aMergeType ) ); if( aRegObj.IsNull() ) continue; Handle(HYDROData_Region) aRegion = aRegionsMap[aRegObj->GetName()]; if( aRegion.IsNull() ) continue; Handle(HYDROData_Zone) aRegionZone = aRegion->addNewZone( theDoc, aZonesPref, aSplitData.Face(), aSplitData.ObjectNames ); + + if( aSplitData.ObjectNames.count() > 1 && aMergeType==HYDROData_Zone::Merge_UNKNOWN ) + { + qDebug( "Error in algorithm: unresolved conflicts" ); + } + switch( aMergeType ) { case HYDROData_Zone::Merge_ZMIN: @@ -304,7 +405,25 @@ void HYDROData_CalculationCase::CreateRegionsAuto( const Handle(HYDROData_Docume } } - //TODO: inform if some regions remain empty + QStringList anObjectsWithEmptyRegions; + QMap::const_iterator + anIt = aRegionsMap.begin(), aLast = aRegionsMap.end(); + for( ; anIt!=aLast; anIt++ ) + { + Handle(HYDROData_Region) aRegion = anIt.value(); + if( aRegion->GetZones().IsEmpty() ) + { + QString aRegName = aRegion->GetName(); + QString anObjName = aRegionNameToObjNameMap[aRegName]; + anObjectsWithEmptyRegions.append( anObjName ); + } + } + + if( !anObjectsWithEmptyRegions.empty() ) + { + QString aData = anObjectsWithEmptyRegions.join( ", " ); + SetWarning( WARN_EMPTY_REGIONS, aData ); + } } void HYDROData_CalculationCase::CreateEdgeGroupsDef( const Handle(HYDROData_Document)& theDoc, @@ -450,6 +569,69 @@ void HYDROData_CalculationCase::RemoveBoundaryPolyline() SetToUpdate( !aPrevPolyline.IsNull() || IsMustBeUpdated() ); } +void HYDROData_CalculationCase::SetStricklerTable( const Handle(HYDROData_StricklerTable)& theStricklerTable ) +{ + Handle(HYDROData_StricklerTable) aPrevStricklerTable = GetStricklerTable(); + + SetReferenceObject( theStricklerTable, DataTag_StricklerTable ); + + // Indicate model of the need to update land covers partition + SetToUpdate( !IsEqual( aPrevStricklerTable, theStricklerTable ) || IsMustBeUpdated() ); +} + +Handle(HYDROData_StricklerTable) HYDROData_CalculationCase::GetStricklerTable() const +{ + return Handle(HYDROData_StricklerTable)::DownCast( + GetReferenceObject( DataTag_StricklerTable ) ); +} + +void HYDROData_CalculationCase::RemoveStricklerTable() +{ + Handle(HYDROData_StricklerTable) aPrevStricklerTable = GetStricklerTable(); + + ClearReferenceObjects( DataTag_StricklerTable ); + + // Indicate model of the need to update land covers partition + SetToUpdate( !aPrevStricklerTable.IsNull() || IsMustBeUpdated() ); +} + +bool HYDROData_CalculationCase::AddLandCover( const Handle(HYDROData_LandCover)& theLandCover ) +{ + if ( HasReference( theLandCover, DataTag_LandCover ) ) + return false; // Land cover is already in reference list + + AddReferenceObject( theLandCover, DataTag_LandCover ); + + // Indicate model of the need to update land covers partition + SetToUpdate( true ); + + return true; +} + +HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetLandCovers() const +{ + return GetReferenceObjects( DataTag_LandCover ); +} + +void HYDROData_CalculationCase::RemoveLandCover( const Handle(HYDROData_LandCover)& theLandCover ) +{ + if ( theLandCover.IsNull() ) + return; + + RemoveReferenceObject( theLandCover->Label(), DataTag_LandCover ); + + // Indicate model of the need to update land cover partition + SetToUpdate( true ); +} + +void HYDROData_CalculationCase::RemoveLandCovers() +{ + ClearReferenceObjects( DataTag_LandCover ); + + // Indicate model of the need to update land cover partition + SetToUpdate( true ); +} + Handle(HYDROData_Region) HYDROData_CalculationCase::AddNewRegion( const Handle(HYDROData_Zone)& theZone ) { Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); @@ -574,10 +756,20 @@ double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& Handle(HYDROData_Zone) aZone = GetZoneFromPoint( thePoint ); if ( !aZone.IsNull() ) { + //DEBTRACE("GetAltitudeForPoint Region " << theRegion->GetName().toStdString() << " Zone " << aZone->GetName().toStdString()); Handle(HYDROData_Region) aRefRegion = Handle(HYDROData_Region)::DownCast( aZone->GetFatherObject() ); if ( IsEqual( aRefRegion, theRegion ) ) aResAltitude = GetAltitudeForPoint( thePoint, aZone ); + else + { + DEBTRACE("GetAltitudeForPoint Region " << aRefRegion->GetName().toStdString() << " Zone " << aZone->GetName().toStdString() << " ---------------------------"); + aResAltitude = GetAltitudeForPoint( thePoint, aZone ); + } } + else + { + DEBTRACE(" --- GetAltitudeForPoint No Zone ---"); + } return aResAltitude; } @@ -585,6 +777,7 @@ double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& thePoint, const Handle(HYDROData_Zone)& theZone ) const { + //DEBTRACE("GetAltitudeForPoint Zone " << theZone->GetName().toStdString()); double aResAltitude = HYDROData_IAltitudeObject::GetInvalidAltitude(); if ( theZone.IsNull() ) return aResAltitude; @@ -672,6 +865,7 @@ NCollection_Sequence HYDROData_CalculationCase::GetAltitudesForPoints( const NCollection_Sequence& thePoints, const Handle(HYDROData_Region)& theRegion ) const { + //DEBTRACE("HYDROData_CalculationCase::GetAltitudesForPoints " << theRegion->GetName().toStdString()); NCollection_Sequence aResSeq; for ( int i = 1, n = thePoints.Length(); i <= n; ++i ) @@ -781,6 +975,7 @@ Handle(HYDROData_Region) HYDROData_CalculationCase::addNewRegion( const Handle(H bool isPrefix ) { TDF_Label aNewLab = myLab.FindChild( DataTag_ChildRegion ).NewChild(); + int aTag = aNewLab.Tag(); Handle(HYDROData_Region) aNewRegion = Handle(HYDROData_Region)::DownCast( HYDROData_Iterator::CreateObject( aNewLab, KIND_REGION ) ); @@ -806,8 +1001,19 @@ Handle(HYDROData_SplittedShapesGroup) HYDROData_CalculationCase::addNewSplittedG return aNewGroup; } +QString HYDROData_CalculationCase::Export( int theStudyId ) const +{ + GEOM::GEOM_Gen_var aGEOMEngine = HYDROData_GeomTool::GetGeomGen(); + SALOMEDS::Study_var aDSStudy = HYDROData_GeomTool::GetStudyByID( theStudyId ); + + QString aGeomObjEntry; + bool isOK = Export( aGEOMEngine, aDSStudy, aGeomObjEntry ); + return isOK ? aGeomObjEntry : QString(); +} + bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var theGeomEngine, - SALOMEDS::Study_ptr theStudy ) const + SALOMEDS::Study_ptr theStudy, + QString& theGeomObjEntry ) const { HYDROData_ShapesGroup::SeqOfGroupsDefs aSeqOfGroupsDefs; @@ -839,20 +1045,21 @@ bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var theGeomEngine, { Handle(HYDROData_Region) aRegion = Handle(HYDROData_Region)::DownCast( aRegionIter.Value() ); - if( aRegion.IsNull() ) + if( aRegion.IsNull() || !aRegion->IsSubmersible() ) continue; TopoDS_Shape aRegionShape = aRegion->GetShape( &aSeqOfGroupsDefs ); aFaces.Append( aRegionShape ); } - return Export( theGeomEngine, theStudy, aFaces, aSeqOfGroupsDefs ); + return Export( theGeomEngine, theStudy, aFaces, aSeqOfGroupsDefs, theGeomObjEntry ); } bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var theGeomEngine, SALOMEDS::Study_ptr theStudy, const TopTools_ListOfShape& theFaces, - const HYDROData_ShapesGroup::SeqOfGroupsDefs& theGroupsDefs ) const + const HYDROData_ShapesGroup::SeqOfGroupsDefs& theGroupsDefs, + QString& theGeomObjEntry ) const { // Sew faces BRepBuilderAPI_Sewing aSewing( Precision::Confusion() * 10.0 ); @@ -906,7 +1113,7 @@ bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var // Publish the sewed shape QString aName = EXPORT_NAME; GEOM::GEOM_Object_ptr aMainShape = - publishShapeInGEOM( theGeomEngine, theStudy, aSewedShape, aName ); + HYDROData_GeomTool::publishShapeInGEOM( theGeomEngine, theStudy, aSewedShape, aName, theGeomObjEntry ); if ( aMainShape->_is_nil() ) return false; @@ -1003,65 +1210,101 @@ bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var return true; } -GEOM::GEOM_Object_ptr HYDROData_CalculationCase::publishShapeInGEOM( - GEOM::GEOM_Gen_var theGeomEngine, SALOMEDS::Study_ptr theStudy, - const TopoDS_Shape& theShape, const QString& theName ) const +void HYDROData_CalculationCase::ClearRules( HYDROData_CalculationCase::DataTag theDataTag, + const bool theIsSetToUpdate ) { - GEOM::GEOM_Object_var aGeomObj; + TDF_Label aRulesLab = myLab.FindChild( theDataTag ); + HYDROData_PriorityQueue::ClearRules( aRulesLab ); - if ( theGeomEngine->_is_nil() || theStudy->_is_nil() || - theShape.IsNull() ) { - return aGeomObj._retn(); + // Indicate model of the need to update splitting + if ( theIsSetToUpdate ) { + SetToUpdate( true ); } +} - std::ostringstream aStreamShape; - // Write TopoDS_Shape in ASCII format to the stream - BRepTools::Write( theShape, aStreamShape ); - // Returns the number of bytes that have been stored in the stream's buffer. - int aSize = aStreamShape.str().size(); - // Allocate octect buffer of required size - CORBA::Octet* anOctetBuf = SALOMEDS::TMPFile::allocbuf( aSize ); - // Copy ostrstream content to the octect buffer - memcpy( anOctetBuf, aStreamShape.str().c_str(), aSize ); - // Create TMPFile - SALOMEDS::TMPFile_var aSeqFile = new SALOMEDS::TMPFile( aSize, aSize, anOctetBuf, 1 ); - - // Restore shape from the stream and get the GEOM object - GEOM::GEOM_IInsertOperations_var anInsOp = theGeomEngine->GetIInsertOperations( theStudy->StudyId() ); - aGeomObj = anInsOp->RestoreShape( aSeqFile ); - - // Puplish the GEOM object - if ( !aGeomObj->_is_nil() ) { - QString aName = GEOMBase::GetDefaultName( theName ); - - SALOMEDS::SObject_var aResultSO = - theGeomEngine->PublishInStudy( theStudy, SALOMEDS::SObject::_nil(), - aGeomObj, qPrintable( aName ) ); - if ( aResultSO->_is_nil() ) { - aGeomObj = GEOM::GEOM_Object::_nil(); - } - } +void HYDROData_CalculationCase::AddRule( const Handle(HYDROData_Entity)& theObject1, + HYDROData_PriorityType thePriority, + const Handle(HYDROData_Entity)& theObject2, + HYDROData_Zone::MergeAltitudesType theMergeType, + HYDROData_CalculationCase::DataTag theDataTag ) +{ + TDF_Label aRulesLab = myLab.FindChild( theDataTag ); + HYDROData_PriorityQueue::AddRule( aRulesLab, theObject1, thePriority, theObject2, theMergeType ); - return aGeomObj._retn(); + // Indicate model of the need to update splitting + SetToUpdate( true ); } -void HYDROData_CalculationCase::ClearRules() +QString HYDROData_CalculationCase::DumpRules() const { TDF_Label aRulesLab = myLab.FindChild( DataTag_CustomRules ); - HYDROData_PriorityQueue::ClearRules( aRulesLab ); + return HYDROData_PriorityQueue::DumpRules( aRulesLab ); } -void HYDROData_CalculationCase::AddRule( const Handle(HYDROData_Object)& theObject1, - HYDROData_PriorityType thePriority, - const Handle(HYDROData_Object)& theObject2, - HYDROData_Zone::MergeAltitudesType theMergeType ) +void HYDROData_CalculationCase::SetAssignmentMode( AssignmentMode theMode ) { - TDF_Label aRulesLab = myLab.FindChild( DataTag_CustomRules ); - HYDROData_PriorityQueue::AddRule( aRulesLab, theObject1, thePriority, theObject2, theMergeType ); + TDF_Label aModeLab = myLab.FindChild( DataTag_AssignmentMode ); + TDataStd_Integer::Set( aModeLab, ( int ) theMode ); + + // Indicate model of the need to update splitting + SetToUpdate( true ); +} + +HYDROData_CalculationCase::AssignmentMode HYDROData_CalculationCase::GetAssignmentMode() const +{ + Handle(TDataStd_Integer) aModeAttr; + bool isOK = myLab.FindChild( DataTag_AssignmentMode ).FindAttribute( TDataStd_Integer::GetID(), aModeAttr ); + if( isOK ) + return ( AssignmentMode ) aModeAttr->Get(); + else + return MANUAL; } -QString HYDROData_CalculationCase::DumpRules() +void HYDROData_CalculationCase::DumpRulesToPython( const QString& theCalcCaseName, + QStringList& theScript ) const { TDF_Label aRulesLab = myLab.FindChild( DataTag_CustomRules ); - return HYDROData_PriorityQueue::DumpRules( aRulesLab ); + HYDROData_PriorityQueue::DumpRulesToPython( aRulesLab, theCalcCaseName, theScript ); +} + +HYDROData_Warning HYDROData_CalculationCase::GetLastWarning() const +{ + return myLastWarning; +} + +void HYDROData_CalculationCase::SetWarning( HYDROData_WarningType theType, const QString& theData ) +{ + myLastWarning.Type = theType; + myLastWarning.Data = theData; +} + +bool HYDROData_CalculationCase::GetRule( int theIndex, + Handle(HYDROData_Entity)& theObject1, + HYDROData_PriorityType& thePriority, + Handle(HYDROData_Entity)& theObject2, + HYDROData_Zone::MergeAltitudesType& theMergeType, + HYDROData_CalculationCase::DataTag& theDataTag) const +{ + TDF_Label aRulesLab = myLab.FindChild( theDataTag ); + return HYDROData_PriorityQueue::GetRule( aRulesLab, theIndex, + theObject1, thePriority, theObject2, theMergeType ); +} + +void HYDROData_CalculationCase::SetAssignmentLandCoverMode( AssignmentMode theMode ) +{ + TDF_Label aModeLab = myLab.FindChild( DataTag_AssignmentLandCoverMode ); + TDataStd_Integer::Set( aModeLab, ( int ) theMode ); + + // Indicate model of the need to update land covers partition + SetToUpdate( true ); +} + +HYDROData_CalculationCase::AssignmentMode HYDROData_CalculationCase::GetAssignmentLandCoverMode() const +{ + Handle(TDataStd_Integer) aModeAttr; + bool isOK = myLab.FindChild( DataTag_AssignmentLandCoverMode ).FindAttribute( TDataStd_Integer::GetID(), aModeAttr ); + if( isOK ) + return ( AssignmentMode ) aModeAttr->Get(); + else + return MANUAL; }