def __readBlocksData(self):
'''
read block data from file
'''
import Base , os
filename = os.path.join(Base.__currentProjectPath__ , 'data.df')
if not os.path.exists(filename):
Base.showErrorMessageBox('FileNotFound', '\'data.df\' file was not found in project path.')
return
from loadDataTools import ParseDFInputGraphData
self.dataParser = ParseDFInputGraphData()
if not self.dataParser.parse(str(filename)):
showErrorMessageBox('Data Error' , 'the schema of file is incorrected')
self.__mainWidget.ui.loadDataLabel.setText('faild')
return
self.__mainWidget.ui.loadDataLabel.setText('sucessed')
print 'DF data parse successfully'
self.__mainWidget.enableConfigPanel(True)
from DDADatabase import df_inputDatabase
data = df_inputDatabase
self.__mainWidget.ui.blockNumLineE.setText(str(len(df_inputDatabase.blockMatCollections)))
print df_inputDatabase.blockMatCollections
self.__mainWidget.ui.jointNumLineE.setText(str(len(df_inputDatabase.jointMatCollections)))
print df_inputDatabase.jointMatCollections
self.dataParser = None
self.__setDefaultParameters()
def __readBlocksData(self):
'''
read block data from file
'''
import Base
filename = str( QtGui.QFileDialog.getOpenFileName(None , 'please select input file' , Base.__currentProjectPath__) )
if not filename:
return
from loadDataTools import ParseDFInputGraphData
self.dataParser = ParseDFInputGraphData()
if not self.dataParser.parse(str(filename)):
showErrorMessageBox('Data Error' , 'the schema of file is incorrected')
return
print 'DF data parse successfully'
self.__enableConfigPanel(True)
from DDADatabase import df_inputDatabase
data = df_inputDatabase
self.configUI.ui.lineE_Path.setText(filename)
self.configUI.ui.lineE_BlockNum.setText(str(len(df_inputDatabase.blockMatCollections)))
self.configUI.ui.lineE_JointNum.setText(str(len(df_inputDatabase.jointMatCollections)))
self.__initMatConfigUI()
self.dataParser = None
class DFCalculation:
'''
process DF
'''
def __init__(self):
self.current_path = __workbenchPath__
self.origin_path = os.getcwd()
self.dataParser = None
#self.__initConfigUI()
self.__initUI()
self.__initConnections()
self.__mainWidget.ui.comboBox.currentIndexChanged.connect(self.__matsWidget.enableEarthquake)
def __initUI(self):
'''
init the DF configuration Panel
'''
self.__mainWidget = Ui_DFPanel()
self.__matsWidget = Ui_DFMaterialPanel()
def __initConnections(self):
'''
init connections in self.configUI.ui
'''
self.__mainWidget.ui.btn_ReadPara.pressed.connect(self.__readParameters)
self.__mainWidget.ui.btn_ReadData.pressed.connect(self.__readBlocksData)
#self.__mainWidget.ui.btn_Calc.pressed.connect(self.__calculateDF)
self.__mainWidget.ui.buttonBox.accepted.connect(self.accept)
self.__mainWidget.ui.btn_Config.pressed.connect(self.__configMats)
def __configMats(self):
if self.__matsWidget.setEarthquakeMaxSteps(self.__mainWidget.ui.stepsNumSpinB.value()):
self.__matsWidget.show()
else:
import Base
Base.showErrorMessageBox("DataError", "The sum of Earthquake steps and earthquake start step numer is bigger than total steps for DDA analysis.\nPlease modify total step number.")
def __readBlocksData(self):
'''
read block data from file
'''
import Base , os
filename = os.path.join(Base.__currentProjectPath__ , 'data.df')
if not os.path.exists(filename):
Base.showErrorMessageBox('FileNotFound', '\'data.df\' file was not found in project path.')
return
from loadDataTools import ParseDFInputGraphData
self.dataParser = ParseDFInputGraphData()
if not self.dataParser.parse(str(filename)):
showErrorMessageBox('Data Error' , 'the schema of file is incorrected')
self.__mainWidget.ui.loadDataLabel.setText('faild')
return
self.__mainWidget.ui.loadDataLabel.setText('sucessed')
print 'DF data parse successfully'
self.__mainWidget.enableConfigPanel(True)
from DDADatabase import df_inputDatabase
data = df_inputDatabase
self.__mainWidget.ui.blockNumLineE.setText(str(len(df_inputDatabase.blockMatCollections)))
print df_inputDatabase.blockMatCollections
self.__mainWidget.ui.jointNumLineE.setText(str(len(df_inputDatabase.jointMatCollections)))
print df_inputDatabase.jointMatCollections
self.dataParser = None
self.__setDefaultParameters()
def __setDefaultParameters(self):
from DDADatabase import df_inputDatabase as dfDB
# block material
self.__matsWidget.setContent(0,[[0.0]*14]*len(dfDB.blockMatCollections))
nums = list(dfDB.blockMatCollections)
for i , n in enumerate(nums):
nums[i] = str(n)
self.__matsWidget.setHeaders4PageIdx(0, nums)
# joint material
self.__matsWidget.setContent(1, [[0.0]*3]*len(dfDB.jointMatCollections))
nums = list(dfDB.jointMatCollections)
for i , n in enumerate(nums):
nums[i] = str(n)
self.__matsWidget.setHeaders4PageIdx(1, nums)
# loading points
self.__matsWidget.setContent(2, [[[0.0]*3]*2]*len(dfDB.loadingPoints))
def __readParameters(self):
'''
read parameters from file
'''
import Base
filename = os.path.join(Base.__currentProjectPath__ , 'parameters.df')
if not os.path.exists(filename):
Base.showErrorMessageBox('FileNotFound', '\'parameters.df\' file was not found in project path.')
return
from loadDataTools import ParseDFInputParameters
parasParser = ParseDFInputParameters()
if not parasParser.parse(str(filename)):
showErrorMessageBox('Data Error' , 'the schema of file is incorrected')
self.__mainWidget.ui.loadParasLabel.setText('faild')
return
self.__mainWidget.ui.loadParasLabel.setText('sucessed')
self.__storePara2Panel()
def __storePara2Panel(self):
from DDADatabase import df_inputDatabase
paras = df_inputDatabase.paras
self.__mainWidget.ui.StaticDynamicSpinB.setValue(paras.ifDynamic)
self.__mainWidget.ui.stepsNumSpinB.setValue(paras.stepsNum)
self.__mainWidget.ui.maxRatioSpinB.setValue(paras.ratio)
self.__mainWidget.ui.timeIntervalSpinB.setValue(paras.OneSteptimeLimit)
self.__mainWidget.ui.springStiffnessSpinB.setValue(paras.springStiffness)
self.__mainWidget.ui.SORSpinB.setValue(paras.SOR)
self.__mainWidget.ui.comboBox.setCurrentIndex(paras.ifRightHand)
self.__matsWidget.setContent(0, paras.blockMats )
print 'blocks mats import done'
self.__matsWidget.setContent(1, paras.jointMats)
print 'joints mats import done'
if(len(paras.loadingPointMats))>0:
self.__matsWidget.setContent(2, paras.loadingPointMats)
print 'loading points import done'
if len(paras.waterControlPoints)>0:
self.__matsWidget.setWaterUnitWeight(paras.waterUnitWeight)
self.__matsWidget.setContent(3, paras.waterControlPoints)
if paras.ifRightHand==1:
self.__matsWidget.setEarthquakeParas(paras.sectionAngle\
, paras.gravityAcceleration , paras.earthquakeTimeInterval)
self.__matsWidget.setEarthquakeMaxSteps(paras.stepsNum)
# self.__matsWidget.setContent(4, paras.earthquakePoints)
def __storePanelData2Database(self):
from DDADatabase import df_inputDatabase
paras = df_inputDatabase.paras
paras.ifDynamic = self.__mainWidget.ui.StaticDynamicSpinB.value()
paras.stepsNum = self.__mainWidget.ui.stepsNumSpinB.value()
paras.ratio = self.__mainWidget.ui.maxRatioSpinB.value()
paras.OneSteptimeLimit = self.__mainWidget.ui.timeIntervalSpinB.value()
paras.springStiffness = self.__mainWidget.ui.springStiffnessSpinB.value()
paras.SOR = self.__mainWidget.ui.SORSpinB.value()
paras.ifRightHand = self.__mainWidget.ui.comboBox.currentIndex()
paras.blockMats = self.__matsWidget.getContent(0)
print 'blocks mats export done'
paras.jointMats = self.__matsWidget.getContent(1)
print 'joints mats export done'
if(len(paras.loadingPointMats))>0:
paras.loadingPointMats = self.__matsWidget.getContent(2)
print 'loading points export done'
#water
paras.waterUnitWeight = self.__matsWidget.ui.waterUnitSpinB.value()
paras.waterControlPoints = self.__matsWidget.getContent(3)
#earthquake
paras.sectionAngle = self.__matsWidget.ui.sectionAngleSpinBox.value()
paras.gravityAcceleration = self.__matsWidget.ui.gravitySpinB.value()
paras.earthquakeTimeInterval = self.__matsWidget.ui.timeSpinB.value()
# paras.earthquakePoints = self.__matsWidget.getContent(4)
def __saveParameters2File(self):
'''
save parameters to self.current_path/parameters.df,and revise df_Ff.c
'''
import Base
outfile = open(Base.__currentProjectPath__+'/parameters.df', 'wb' )
print Base.__currentProjectPath__+'/parameters.df'
if not outfile:
showErrorMessageBox('File open failed' , 'Can\'t open parameters.df')
return
# schema
from DDADatabase import df_inputDatabase
paras = df_inputDatabase.paras
tmpUI = self.__mainWidget.ui
outfile.write('%f\n%d\n%d\n%d\n%f\n%f\n%f\n'%(paras.ifDynamic\
, int(paras.stepsNum) , int(paras.blockMatsNum)\
, int(paras.jointMatsNum) , paras.ratio\
, paras.OneSteptimeLimit , paras.springStiffness))
print 'schema store done.'
# fixed points and loading points
if len(df_inputDatabase.fixedPoints)>0:
fps = len(df_inputDatabase.fixedPoints)
outfile.write('0 '*fps )
print 'fixed points : ' ,fps
if len(paras.loadingPointMats)>0:
for lp in paras.loadingPointMats:
outfile.write('%d '%len(lp))
print 'loading points : ' , paras.loadingPointMats
outfile.write('\n')
for lp in paras.loadingPointMats:
for nums in lp:
outfile.write( '%f %f %f\n'%tuple(nums))
print 'fixed points and loading points materials store done.'
# block materials
for block in paras.blockMats:
outfile.write( '%f %f %f %f %f\n%f %f %f\n%f %f %f\n%f %f %f\n'%(block[0] ,block[1] ,block[2]\
,block[3] ,block[4] ,block[5] ,block[6] ,block[7] ,block[8] ,block[9] ,block[10]\
,block[11] ,block[12] ,block[13]))
print 'block materials store done.'
# joints materials
for joint in paras.jointMats:
outfile.write( '%f %f %f\n'%(joint[0] ,joint[1] ,joint[2]))
print 'joint materials store done.'
# rest parameters
if paras.ifRightHand==1: # right hand
outfile.write('%s\n0 1 2\n'%str(self.__mainWidget.ui.SORSpinB.value()))
else:
outfile.write('%s\n0 0 0\n'%str(self.__mainWidget.ui.SORSpinB.value()))
print 'all parameters store done.'
# water
outfile.write('%f\n%d %f\n'%(paras.sectionAngle \
,len(paras.waterControlPoints) , paras.waterUnitWeight))
for nums in paras.waterControlPoints:
outfile.write('%f %f\n'%tuple(nums))
outfile.close()
#earthquake
if not paras.ifRightHand: return
self.__matsWidget.storeEarthquakeData()
def accept(self):
self.__storePanelData2Database()
import Base
Base.delaycommand(self.__calculateDF)
def __calculateDF(self):
'''
save parameters to self.current_path/parameters.df , and then start calculation
'''
self.__saveParameters2File()
print 'Calculation button pressed'
def __calc():
import FreeCADGui
FreeCADGui.runCommand('DDA_DFCalc')
import DDAGui
DDAGui.setInterval4Calculation(self.__mainWidget.ui.spinB_framesInterval.value())
import Base
Base.delaycommand(__calc)
def GetResources(self):
return {'Pixmap' :'DF',
'MenuText': QtCore.QT_TRANSLATE_NOOP('DFCalculation','DFCalculation'),
'ToolTip': QtCore.QT_TRANSLATE_NOOP('DFCalculation',"DF calculation process.")}
def Activated(self, name="None"):
FreeCAD.Console.PrintMessage( 'Creator activing\n')
if FreeCAD.activeDDACommand:
FreeCAD.activeDDACommand.finish()
self.doc = FreeCAD.ActiveDocument
self.view = FreeCADGui.ActiveDocument.ActiveView
self.featureName = name
if not self.doc:
FreeCAD.Console.PrintMessage( 'FreeCAD.ActiveDocument get failed\n')
self.finish()
else:
FreeCAD.activeDDACommand = self # FreeCAD.activeDDACommand 在不同的时间会接收不同的命令
import Base
Base.__currentStage__ = 'DF'
#self.ui.show()
# Hide Panel
Base.setCurrentDDACommand(self)
self.__mainWidget.show()
# clear Dcoument
import DDADisplay
DDADisplay.clearDocument()
def IsActive(self):
import Base
return Base.ifReady4Drawing('DDA')
def finish(self):
pass
def hideUI(self):
self.__mainWidget.hide()
import DDAGui
DDAGui.clearCalculator()
class DFCalculation:
'''
process DF
'''
def __init__(self):
self.current_path = __workbenchPath__
self.origin_path = os.getcwd()
self.dataParser = None
self.__initConfigUI()
self.__initConnections()
self.__enableConfigPanel(False)
def __initConfigUI(self):
'''
init the DF configuration Panel
'''
self.configUI = Ui_DFConfigurationPanel()
self.matConfigUI = None
def __initMatConfigUI(self):
if self.matConfigUI:
self.configUI.ui.btn_Config.pressed.disconnect(self.matConfigUI.show)
import Base
from DDADatabase import df_inputDatabase
self.matConfigUI = Ui_DFMatParaConfigPanel(len(df_inputDatabase.blockMatCollections) \
, self.dataParser.loadingPointsNum, len(df_inputDatabase.jointMatCollections) )
self.configUI.ui.btn_Config.pressed.connect(self.matConfigUI.show)
def __initConnections(self):
'''
init connections in self.configUI.ui
'''
self.configUI.ui.btn_ReadPara.pressed.connect(self.__readParameters)
self.configUI.ui.btn_ReadData.pressed.connect(self.__readBlocksData)
self.configUI.ui.btn_Calc.pressed.connect(self.__calculateDF)
def __enableConfigPanel(self , flag):
print 'set configuration panel : ' , flag
self.configUI.ui.btn_ReadPara.setEnabled(flag)
self.configUI.ui.btn_Config.setEnabled(flag)
self.configUI.ui.btn_Calc.setEnabled(flag)
self.configUI.ui.doubleSpinBox_IFStatic.setEnabled(flag)
self.configUI.ui.spinBox__NumStep.setEnabled(flag)
self.configUI.ui.spinBox_Ratio.setEnabled(flag)
self.configUI.ui.spinBox_timeInterval.setEnabled(flag)
self.configUI.ui.spinBox_SpringStiffness.setEnabled(flag)
self.configUI.ui.spinBox_SOR.setEnabled(flag)
def __readBlocksData(self):
'''
read block data from file
'''
import Base
filename = str( QtGui.QFileDialog.getOpenFileName(None , 'please select input file' , Base.__currentProjectPath__) )
if not filename:
return
from loadDataTools import ParseDFInputGraphData
self.dataParser = ParseDFInputGraphData()
if not self.dataParser.parse(str(filename)):
showErrorMessageBox('Data Error' , 'the schema of file is incorrected')
return
print 'DF data parse successfully'
self.__enableConfigPanel(True)
from DDADatabase import df_inputDatabase
data = df_inputDatabase
self.configUI.ui.lineE_Path.setText(filename)
self.configUI.ui.lineE_BlockNum.setText(str(len(df_inputDatabase.blockMatCollections)))
self.configUI.ui.lineE_JointNum.setText(str(len(df_inputDatabase.jointMatCollections)))
self.__initMatConfigUI()
self.dataParser = None
def __readParameters(self):
'''
read parameters from file
'''
import Base
filename = str( QtGui.QFileDialog.getOpenFileName(None , 'please select input file' , Base.__currentProjectPath__) )
if not filename:
return
from loadDataTools import ParseDFInputParameters
parasParser = ParseDFInputParameters()
if not parasParser.parse(str(filename)):
showErrorMessageBox('Data Error' , 'the schema of file is incorrected')
return
self.__storePara2Panel()
def __storePara2Panel(self):
from DDADatabase import df_inputDatabase
paras = df_inputDatabase.paras
self.configUI.ui.doubleSpinBox_IFStatic.setValue(paras.ifDynamic)
self.configUI.ui.spinBox__NumStep.setValue(paras.stepsNum)
self.configUI.ui.spinBox_Ratio.setValue(paras.ratio)
self.configUI.ui.spinBox_timeInterval.setValue(paras.OneSteptimeLimit)
self.configUI.ui.spinBox_SpringStiffness.setValue(paras.springStiffness)
self.configUI.ui.spinBox_SOR.setValue(paras.SOR)
self.matConfigUI.dataTableBLocksMats.writeData2Table(paras.blockMats)
print 'blocks mats import done'
self.matConfigUI.dataTableJointsMats.writeData2Table(paras.jointMats)
print 'joints mats import done'
if(len(paras.loadingPointMats))>0:
self.matConfigUI.dataTableLoadingPointsMats.writeData2Table(paras.loadingPoints)
print 'loading points import done'
def __saveParameters2File(self):
'''
save parameters to self.current_path/parameters.df,and revise df_Ff.c
'''
import Base
outfile = open(Base.__currentProjectPath__+'/parameters.df', 'wb' )
if not outfile:
showErrorMessageBox('File open failed' , 'Can\'t open parameters.df')
return
# schema
tmpUI = self.configUI.ui
outfile.write('%s\n%s\n%s\n%s\n%s\n%s\n%s\n'%(str(tmpUI.doubleSpinBox_IFStatic.text())\
, str(tmpUI.spinBox__NumStep.text()) , str(tmpUI.lineE_BlockNum.text())\
, str(tmpUI.lineE_JointNum.text()) , str(tmpUI.spinBox_Ratio.text())\
, str(tmpUI.spinBox_timeInterval.text()) , str(tmpUI.spinBox_SpringStiffness.text())))
print 'schema store done.'
# fixed points and loading points
from DDADatabase import df_inputDatabase
if len(df_inputDatabase.fixedPoints)>0:
fps = len(df_inputDatabase.fixedPoints)
outfile.write('0 '*fps +'\n')
print 'fixed points : ' ,fps
if len(df_inputDatabase.loadingPoints)>0:
lps = len(df_inputDatabase.loadingPoints)
outfile.write('2 '*lps +'\n')
print 'loading points : ' , lps
tmpTable = self.matConfigUI.tableLoadingPointsMats
nums = [1]*6
for i in range(len(df_inputDatabase.loadingPoints)):
for j in range(6):
nums[j] = str(tmpTable.item(i,j).text())
outfile.write( '%s %s %s\n%s %s %s\n'%(nums[0] ,nums[1] ,nums[2] ,nums[3] ,nums[4] ,nums[5] ))
print 'fixed points and loading points materials store done.'
# block materials
tmpTable = self.matConfigUI.tableBLocksMats
nums = [1]*14
for i in range(tmpTable.rowCount()):
for j in range(14):
nums[j] = str(tmpTable.item(i,j).text())
outfile.write( '%s %s %s %s %s\n%s %s %s\n%s %s %s\n%s %s %s\n'%(nums[0] ,nums[1] ,nums[2]\
,nums[3] ,nums[4] ,nums[5] ,nums[6] ,nums[7] ,nums[8] ,nums[9] ,nums[10]\
,nums[11] ,nums[12] ,nums[13]))
print 'block materials store done.'
# joints materials
tmpTable = self.matConfigUI.tableJointsMats
nums = [1]*3
for i in range(tmpTable.rowCount()):
for j in range(3):
nums[j] = str(tmpTable.item(i,j).text())
outfile.write( '%s %s %s\n'%(nums[0] ,nums[1] ,nums[2]))
print 'joint materials store done.'
# rest parameters
outfile.write('%s\n0 0 0'%str(self.configUI.ui.spinBox_SOR.text()))
print 'all parameters store done.'
outfile.close()
import Base
outfile = open(Base.__workbenchPath__+'/df_Ff.c' , 'wb')
outfile.write(str(self.configUI.ui.lineE_Path.text())+'\n')
outfile.write(Base.__currentProjectPath__+'/parameters.df')
outfile.close()
def __calculateDF(self):
'''
save parameters to self.current_path/parameters.df , and then start calculation
'''
if not self.matConfigUI.ifMatConfigPanelOK(): # all 3 tables' parameters are valid
showErrorMessageBox('Data Error' , 'check recorrect parameters in tables')
return
self.__saveParameters2File()
print 'Calculation button pressed'
import os
originPath = os.getcwd()
import Base
print 'change dir to ' , Base.__workbenchPath__
os.chdir(Base.__workbenchPath__)
# begin to calculation
processDialog = Ui_DFCalculationProcess()
print 'processbar widget showed'
import Base
f = open(Base.__currentProjectPath__+'/data.dg' , 'wb') # clear file
f.close()
maxSteps = int(str(self.configUI.ui.spinBox__NumStep.text()))
# maxSteps = 20000
processDialog.ui.progressBar.setMaximum(maxSteps)
processDialog.show()
process = PyDDA.DF()
process.calculationInit()
for i in range(maxSteps):
process.calculate1Step()
processDialog.ui.progressBar.setValue(i)
processDialog.ui.label_rate.setText('steps : %d /%d '%(i , maxSteps))
e=QtCore.QEventLoop()
e.processEvents()
file = open('dg_ff.c' , 'wb')
file.write(Base.__currentProjectPath__+'/data.dg')
file.close()
print 'change dir to ' , originPath
os.chdir(originPath)
def GetResources(self):
return {
'MenuText': 'DFCalculation',
'ToolTip': "DF calculation process."}
def Activated(self, name="None"):
FreeCAD.Console.PrintMessage( 'Creator activing\n')
if FreeCAD.activeDDACommand:
FreeCAD.activeDDACommand.finish()
self.doc = FreeCAD.ActiveDocument
self.view = FreeCADGui.ActiveDocument.ActiveView
self.featureName = name
self.ui = None
if not self.doc:
FreeCAD.Console.PrintMessage( 'FreeCAD.ActiveDocument get failed\n')
self.finish()
else:
FreeCAD.activeDDACommand = self # FreeCAD.activeDDACommand 在不同的时间会接收不同的命令
import Base
Base.__currentStage__ = 'DF'
#self.ui.show()
# Hide Panel
if __currentDDAPanel__ != None :
__currentDDAPanel__.hide()
self.configUI.show()
def IsActive(self):
if FreeCADGui.ActiveDocument:
import Base
if len(Base.__workbenchPath__)>1 and len(Base.__currentProjectPath__)>0:
return True
else:
return False
def finish(self):
pass
