def getContour(self): ''' Return the base plate contour. ''' retval= geom.Polygon2d() deltaX= self.B/2.0 deltaY= self.N/2.0 origin2d= geom.Pos2d(self.origin.x, self.origin.y) retval.appendVertex(origin2d+geom.Vector2d(deltaX+self.offsetB,deltaY+self.offsetN)) retval.appendVertex(origin2d+geom.Vector2d(-deltaX+self.offsetB,deltaY+self.offsetN)) retval.appendVertex(origin2d+geom.Vector2d(-deltaX+self.offsetB,-deltaY+self.offsetN)) retval.appendVertex(origin2d+geom.Vector2d(deltaX+self.offsetB,-deltaY+self.offsetN)) return retval
def movePointsRangeToYcylinder(self,ijkRange,xCent,zCent,R): '''Moves the points in the range to make them belong to a cylinder with radius R and axis parallel to global Y passing through the point (xCent,0,zCent) ''' vCent=geom.Vector2d(xCent,zCent) setPnt=self.getSetPntRange(ijkRange,'setPnt') for p in setPnt.getPoints: v=geom.Vector2d(p.getPos.x,p.getPos.z)-vCent vdir=v.normalizado() p.getPos.x=xCent+R*vdir.x p.getPos.z=zCent+R*vdir.y setPnt.clear()
def getSVDfromVDesliz(DOFs, coo, v): # Returns a SVD which represents vector. if (DOFs == "UV"): return geom.SVD2d(geom.Pos2d(coo[0], coo[1]), geom.Vector2d(v[0], v[1])) elif (DOFs == "UVR"): return geom.SVD2d(geom.Pos2d(coo[0], coo[1]), geom.Vector2d(v[0], v[1]), v[2]) elif (DOFs == "UVW"): return geom.SVD3d(geom.Pos3d(coo[0], coo[1], coo[2]), geom.Vector3d(v[0], v[1], v[2])) elif (DOFs == "UVWRxRyRz"): return geom.SVD3d(geom.Pos3d(coo[0], coo[1], coo[2]), geom.Vector3d(v[0], v[1], v[2]), geom.Vector3d(v[3], v[4], v[5]))
def __init__(self,preprocessor,supportNodes): self.forces= dict() self.moments= dict() self.positions= dict() self.svdReac= geom.SVD3d() meshNodes= preprocessor.getNodeLoader meshNodes.calculateNodalReactions(True) f3d= geom.Vector3d(0.0,0.0,0.0) m3d= geom.Vector3d(0.0,0.0,0.0) for n in supportNodes: tag= n.tag tmp= n.getReaction if(meshNodes.numDOFs==3): force= geom.Vector2d(tmp[0],tmp[1]) f3d= geom.Vector3d(tmp[0],tmp[1],0.0) moment= geom.Vector3d(0.0,0.0,tmp[2]) m3d= moment else: force= geom.Vector3d(tmp[0],tmp[1],tmp[2]) f3d= force moment= geom.Vector3d(tmp[3],tmp[4],tmp[5]) m3d= moment self.forces[tag]= force self.moments[tag]= moment pos= n.getInitialPos3d self.positions[tag]= pos self.svdReac+= geom.SVD3d(pos,f3d,m3d)
def __init__(self, boltArray, width=None, length=None, thickness=10e-3, steelType=None, eccentricity=geom.Vector2d(0.0, 0.0), doublePlate=False): ''' Constructor. :param boltArray: bolt array. :param width: plate width (if None it will be computed from the bolt arrangement.) :param length: plate length (if None it will be computed from the bolt arrangement.) :param thickness: plate thickness. :param steelType: steel type. :param eccentricity: eccentricity of the plate with respect the center of the bolt array. :param doublePlate: if true there is one plate on each side of the main member. ''' self.width = width self.length = length self.setBoltArray(boltArray) self.thickness = thickness self.steelType = steelType self.eccentricity = eccentricity self.doublePlate = doublePlate
def __init__(self, preprocessor, supportNodes, inclInertia=False): ''' Constructor. :param preprocessor: XC preprocessor of the problem. :param supportNodes: nodes to compute reactions. :param inclInertia: include inertia effects (defaults to false). ''' self.forces = dict() self.moments = dict() self.positions = dict() self.svdReac = geom.SlidingVectorsSystem3d() nodeHandler = preprocessor.getNodeHandler nodeHandler.calculateNodalReactions(inclInertia, 1e-7) f3d = geom.Vector3d(0.0, 0.0, 0.0) m3d = geom.Vector3d(0.0, 0.0, 0.0) for n in supportNodes: tag = n.tag tmp = n.getReaction f3d = n.getReactionForce3d m3d = n.getReactionMoment3d if (nodeHandler.numDOFs == 3): force = geom.Vector2d(f3d.x, f3d.y) else: force = f3d self.forces[tag] = force self.moments[tag] = m3d pos = n.getInitialPos3d self.positions[tag] = pos self.svdReac += geom.SlidingVectorsSystem3d(pos, f3d, m3d)
def getSlidingVectorsSystemfromSlidingVector(DOFs,coo,v): '''Returns a sliding vector system equivalent to the sliding vector. Parameters: :param DOFs: degrees of freedom. :param coo: coordinates of a point in the vector line of action. :param v: vector. ''' if(DOFs=="UV"): return geom.SlidingVectorsSystem2d(geom.Pos2d(coo[0],coo[1]),geom.Vector2d(v[0],v[1])) elif(DOFs=="UVR"): return geom.SlidingVectorsSystem2d(geom.Pos2d(coo[0],coo[1]),geom.Vector2d(v[0],v[1]),v[2]) elif(DOFs=="UVW"): return geom.SlidingVectorsSystem3d(geom.Pos3d(coo[0],coo[1],coo[2]),geom.Vector3d(v[0],v[1],v[2])) elif(DOFs=="UVWRxRyRz"): return geom.SlidingVectorsSystem3d(geom.Pos3d(coo[0],coo[1],coo[2]),geom.Vector3d(v[0],v[1],v[2]),geom.Vector3d(v[3],v[4],v[5]))
def getSVDfromVDesliz(DOFs,coo,v): '''Returns a sliding vector system that represents the vector. Parameters: :param DOFs: degrees of freedom. :param coo: coordinates of a point in the vector line of action. :param v: vector. ''' if(DOFs=="UV"): return geom.SVD2d(geom.Pos2d(coo[0],coo[1]),geom.Vector2d(v[0],v[1])) elif(DOFs=="UVR"): return geom.SVD2d(geom.Pos2d(coo[0],coo[1]),geom.Vector2d(v[0],v[1]),v[2]) elif(DOFs=="UVW"): return geom.SVD3d(geom.Pos3d(coo[0],coo[1],coo[2]),geom.Vector3d(v[0],v[1],v[2])) elif(DOFs=="UVWRxRyRz"): return geom.SVD3d(geom.Pos3d(coo[0],coo[1],coo[2]),geom.Vector3d(v[0],v[1],v[2]),geom.Vector3d(v[3],v[4],v[5]))
def getFoundationCenterPosition(self): ''' Returns the position of the foundation center (for excentricity computation).''' toeEndPos= self.getWFToeEndPosition() heelEndPos= self.getWFHeelEndPosition() v= (heelEndPos-toeEndPos)*0.5+geom.Vector2d(0.0,-self.footingThickness/2.0) return toeEndPos+v
def getBoltedPlateTemplate(self): ''' Return the blocks corresponding to the plate bolted to the gusset plate. ''' # Create bolted plate. boltedPlate = ASTM_materials.BoltedPlate() boltedPlate.setFromDict(self.boltedPlateTemplate.getDict()) boltedPlate.eccentricity = geom.Vector2d(.025, 0.0) boltedPlate.length += .05 return boltedPlate
def writeDXFAnchorBolts(self, modelSpace, layerName): ''' Draw anchor bolts :param modelSpace: model space to write into. :param layerName: layer name. ''' boltDiameter = self.anchorGroup.anchors[0].diameter self.holeDiameter = self.getHoleDiameter() origin2d = geom.Pos2d(self.origin.x, self.origin.y) for anchor in self.anchorGroup.anchors: center = origin2d + geom.Vector2d(anchor.pos3d.x, anchor.pos3d.y) modelSpace.add_circle((center.x, center.y), self.holeDiameter / 2.0, dxfattribs={'layer': layerName})
def Cp(self, x, y): '''External wind pressure coefficient in a point of the cylinder with coordinates (x,y) - Cp (+) -> pressure acts toward external surface - Cp (-) -> pressure acts away from external surface ''' vectPoint = geom.Vector2d(x - self.xCent, y - self.yCent) theta = self.vectRef.getAngle(vectPoint) Cp1 = self.Cp1_theta(theta) kc = self.kc(Cp1) Cp = kc * Cp1 return Cp
def __init__(self, diam, height, windParams, windComp=[1, 0], zGround=0, xCent=0, yCent=0): self.diam = diam self.height = height self.windParams = windParams self.windComp = windComp self.zGround = zGround self.xCent = xCent self.yCent = yCent self.vectRef = geom.Vector2d(-windComp[0], -windComp[1])
def writeDXFShapeContour(self, modelSpace, layerName): ''' Writes the shape contour in the model space argument. :param modelSpace: model space to write into. :param layerName: layer name. ''' plg = self.steelShape.getContour() posVec3d = self.origin.getPositionVector() posVec2d = geom.Vector2d(posVec3d.x, posVec3d.y) plg.move(posVec2d) vtx = plg.getVertices() vtx.append(vtx[0]) v0 = vtx[0] for v in vtx[1:]: modelSpace.add_line((v0.x, v0.y), (v.x, v.y), dxfattribs={'layer': layerName}) v0 = v
def getSlidingSafetyFactor(self,R,gammaR,foundationSoilModel): '''Return the factor of safety against sliding. :param R: (SlidingVectorsSystem3d) resultant of the loads acting on the retaining wall. :param gammaR: partial resistance reduction factor. :param foundationSoilModel: (FrictionalCohesionalSoil) soil model. :param gammaMPhi: (float) partial reduction factor for internal friction angle of the soil. :param gammaMc: (float) partial reduction factor for soil cohesion. ''' foundationPlane= self.getFoundationPlane() alphaAngle= math.atan(foundationPlane.getSlope()) F= R.getResultant() F2D= geom.Vector2d(F.x,F.y) Ftang= foundationPlane.getVector2dProj(F2D) Fnormal= F2D-Ftang #Sliding strength e= self.getEccentricity(R) #eccentricity b= self.getFootingWidth() bReduced= 2*(b/2.0+e) Rd= Fnormal.getModulus()*math.tan(foundationSoilModel.getDesignPhi())+foundationSoilModel.getDesignC()*bReduced/math.cos(alphaAngle) return Rd/Ftang.getModulus()/gammaR
def getContourPoints(self): ''' Return a list with the points that form the wall contour.''' retval= list() retval.append(self.stemTopPosition) stemInsideBottom= self.stemTopPosition-geom.Vector2d(0.0,self.stemHeight) retval.append(stemInsideBottom) toePosTop= stemInsideBottom+geom.Vector2d(-self.bToe, 0.0) # toe retval.append(toePosTop) toePosBottom= toePosTop-geom.Vector2d(0.0,self.footingThickness) retval.append(toePosBottom) heelEndPosBottom= toePosBottom+geom.Vector2d(self.getFootingWidth(), 0.0) # heel end retval.append(heelEndPosBottom) heelEndPosTop= heelEndPosBottom+geom.Vector2d(0.0, self.footingThickness) retval.append(heelEndPosTop) stemOutsideTop= self.stemTopPosition+geom.Vector2d(self.stemTopWidth,0.0) # stem top stemOutsideBottom= stemOutsideTop+geom.Vector2d(self.stemHeight*self.stemBackSlope,-self.stemHeight) #stem bottom retval.append(stemOutsideBottom) retval.append(stemOutsideTop) # stem top return retval
def __init__(self, preprocessor, supportNodes): self.forces = dict() self.moments = dict() self.positions = dict() self.svdReac = geom.SlidingVectorsSystem3d() nodeHandler = preprocessor.getNodeHandler nodeHandler.calculateNodalReactions(True, 1e-7) f3d = geom.Vector3d(0.0, 0.0, 0.0) m3d = geom.Vector3d(0.0, 0.0, 0.0) for n in supportNodes: tag = n.tag tmp = n.getReaction f3d = n.getReactionForce3d m3d = n.getReactionMoment3d if (nodeHandler.numDOFs == 3): force = geom.Vector2d(f3d.x, f3d.y) else: force = f3d self.forces[tag] = force self.moments[tag] = m3d pos = n.getInitialPos3d self.positions[tag] = pos self.svdReac += geom.SlidingVectorsSystem3d(pos, f3d, m3d)
def getWFStemTopPosition(self): ''' Returns the position of the stem top in the wireframe model.''' return self.stemTopPosition-geom.Vector2d(self.stemTopWidth/2.0,0.0)
kip2N = 4448.2216 import xc_base import geom from materials.astm_aisc import ASTM_materials bolt = ASTM_materials.BoltFastener(0.75 * in2m, steelType=ASTM_materials.A325) # group A boltArray = ASTM_materials.BoltArray(bolt, nRows=4, nCols=1, dist=3 * in2m) eccentr = (4.5 / 2.0 - 1.25) * in2m finPlate = ASTM_materials.FinPlate(boltArray, width=11.5 * in2m, length=4.5 * in2m, thickness=0.25 * in2m, steelType=ASTM_materials.A36, eccentricity=geom.Vector2d(eccentr, 0.0)) Rd = 49.6 * kip2N ## Check bolt strength CFShear = boltArray.getDesignShearEfficiency(Rd, doubleShear=False) loadDir = geom.Vector2d(0.0, -1.0) CF = finPlate.getDesignEfficiency(geom.Vector2d(0.0, -Rd), Ubs=1.0) CFRef = 49.6 / 52.2 ratio1 = abs(CF - CFRef) / CFRef ''' print('Rd= ', Rd/1e3, 'kN') print('CF(Shear)= ', CFShear) print('CF= ', CF) print('ratio1= ', ratio1) '''
fv= sigma_h*math.tan(delta)*stepHeight Fv+= fv x.append(z)r results5_16.append(sigma_h) totalEarthPressure= scipy.integrate.simps(results5_16,x) earthPressurePolygon=geom.Polygon2d() for cx,cy in zip(x,results5_16): earthPressurePolygon.appendVertex(geom.Pos2d(cx,cy)) earthPressurePolygon.appendVertex(geom.Pos2d(x[-1],0.0)) earthPressurePolygon.appendVertex(geom.Pos2d(0,0)) earthPressurePolygonCentroid= earthPressurePolygon.getCenterOfMass() earthPressureVector= geom.Vector2d(-totalEarthPressure,-Fv) earthPressureTail= geom.Pos2d(foundationWidth,H-earthPressurePolygonCentroid.x) earthPressureSVS= geom.SlidingVectorsSystem2d(geom.SlidingVector2d(earthPressureTail,earthPressureVector)) print 'earthPressureSVS: ', earthPressureSVS ''' print 'B/H= 0.1', results5_16 ''' # Spandrel wall. foundationCenter= geom.Pos2d(foundationWidth/2.0,0.0) spandrelWallPolygon= geom.Polygon2d() spandrelWallPolygon.appendVertex(geom.Pos2d(0.0,0.0)) spandrelWallPolygon.appendVertex(geom.Pos2d(foundationWidth,0.0)) spandrelWallPolygon.appendVertex(geom.Pos2d(1.05,H)) spandrelWallPolygon.appendVertex(geom.Pos2d(0.00,H))
# -*- coding: utf-8 -*- import xc_base import geom pol1 = geom.Polygon2d() pol1.appendVertex(geom.Pos2d(-1., -1.)) pol1.appendVertex(geom.Pos2d(1., -1.)) pol1.appendVertex(geom.Pos2d(1., 1.)) pol1.appendVertex(geom.Pos2d(-1., 1.)) pol2 = geom.Polygon2d(pol1) pol2.mueve(geom.Vector2d(1, 1)) pol3 = geom.Polygon2d(pol1) pol3.clipUsingPolygon(pol2) areaPol = pol3.getArea() polygonPerimeter = pol3.getPerimeter() polygonCenterOfMass = pol3.getCenterOfMass() polygonCenterOfMassX = polygonCenterOfMass.x polygonCenterOfMassY = polygonCenterOfMass.y IxPol = pol3.getIx() IyPol = pol3.getIy() PxyPol = pol3.getPxy() ratio1 = (areaPol - 1) ratio2 = (polygonPerimeter - 4) / 4. ratio3 = (polygonCenterOfMassX - 0.5) / 0.5 ratio4 = (polygonCenterOfMassY - 0.5) / 0.5 ratio5 = (IxPol - (1 / 12.0)) / (1 / 12.0) ratio6 = (IyPol - (1 / 12.0)) / (1 / 12.0) ratio7 = PxyPol
# -*- coding: utf-8 -*- import xc_base import geom import math u=geom.Vector2d(1,0) ptoOrigen=geom.Pos2d(0,0) ptoDestino=geom.Pos2d(1,1) s=geom.Segment2d(ptoOrigen,ptoDestino) alpha=s.angleVector(u) ratio1= math.degrees(alpha)-45 ptoDestino=geom.Pos2d(0,1) s=geom.Segment2d(ptoOrigen,ptoDestino) alpha=s.angleVector(u) ratio2= math.degrees(alpha)-90 ptoDestino=geom.Pos2d(-1,1) s=geom.Segment2d(ptoOrigen,ptoDestino) alpha=s.angleVector(u) ratio3= math.degrees(alpha)-135 ptoDestino=geom.Pos2d(-1,0) s=geom.Segment2d(ptoOrigen,ptoDestino) alpha=s.angleVector(u) ratio4= math.degrees(alpha)-180 ptoDestino=geom.Pos2d(-1,-1) s=geom.Segment2d(ptoOrigen,ptoDestino) alpha=s.angleVector(u)
# -*- coding: utf-8 -*- import xc_base import geom import math circ1 = geom.Circle2d(geom.Pos2d(0.0, 0.0), 1.0) alpha = math.radians(0) v = geom.Vector2d(math.cos(alpha), math.sin(alpha)) pol1 = circ1.getInscribedPolygon(3, 0) ptsTang = pol1.getApproxTangentPositions(v) pt0 = ptsTang[0] pt0Teor = geom.Pos2d(-0.125, -0.649519) alpha = math.radians(45) v = geom.Vector2d(math.cos(alpha), math.sin(alpha)) ptsTang = pol1.getApproxTangentPositions(v) pt1Teor = geom.Pos2d(0.4375, -0.32476) pt1 = ptsTang[0] alpha = math.radians(90) v = geom.Vector2d(math.cos(alpha), math.sin(alpha)) ptsTang = pol1.getApproxTangentPositions(v) pt2Teor = geom.Pos2d(1, 0) pt2 = ptsTang[0] alpha = math.radians(135) v = geom.Vector2d(math.cos(alpha), math.sin(alpha)) ptsTang = pol1.getApproxTangentPositions(v) pt3Teor = geom.Pos2d(0.4375, 0.32476)
def getFoundationPlane(self): ''' Returns the foundation plane.''' v = geom.Vector2d(0.0, -self.footingThickness / 2.0) toeEndPos = self.getWFToeEndPosition() + v heelEndPos = self.getWFHeelEndPosition() + v return geom.Line2d(toeEndPos, heelEndPos)
def getToePosition(self): ''' Returns the position of the toe (for overturning moment computation).''' return self.getWFToeEndPosition() + geom.Vector2d( 0.0, -self.footingThickness / 2.0)
ratio3 = 10 feProblem = xc.FEProblem() preprocessor = feProblem.getPreprocessor # Define materials scc = typical_materials.defElasticSection3d(preprocessor, "scc", 1, 1, 1, Iz, Iy, 4) scc.sectionProperties.rotate(math.radians(45)) I1 = scc.sectionProperties.getI1() I2 = scc.sectionProperties.getI2() I1axis = scc.sectionProperties.getAxis1VDir() I2axis = scc.sectionProperties.getAxis2VDir() strongAxis = scc.sectionProperties.getVDirStrongAxis() weakAxis = scc.sectionProperties.getVDirWeakAxis() strongAxisTeor = geom.Vector2d(math.sqrt(2) / 2, math.sqrt(2) / 2) ratio0 = (strongAxis - strongAxisTeor).getModulus() ratio1 = (I1axis - strongAxisTeor).getModulus() weakAxisTeor = geom.Vector2d(-math.sqrt(2) / 2, math.sqrt(2) / 2) ratio2 = (weakAxis - weakAxisTeor).getModulus() ratio3 = (I2axis - weakAxisTeor).getModulus() ''' print "Iz: ",Iz print "I1: ",I1 print "Axis 1: ",I1axis print "Strong axis: ",strongAxis print "Iy: ",Iy print "I2: ",I2 print "Axis 2: ",I2axis print "Weak axis: ",weakAxis print "ratio0= ",ratio0
ratio2= 10 ratio3= 10 prueba= xc.ProblemaEF() preprocessor= prueba.getPreprocessor # Define materials scc= typical_materials.defElasticSection3d(preprocessor, "scc",1,1,1,Iz,Iy,4) scc.sectionProperties.rotate(math.radians(45)) I1= scc.sectionProperties.getI1() I2= scc.sectionProperties.getI2() ejeI1= scc.sectionProperties.getVDirEje1() ejeI2= scc.sectionProperties.getVDirEje2() ejeFuerte= scc.sectionProperties.getVDirStrongAxis() ejeDebil= scc.sectionProperties.getVDirWeakAxis() ejeFuerteTeor= geom.Vector2d(math.sqrt(2)/2,math.sqrt(2)/2) ratio0= (ejeFuerte-ejeFuerteTeor).getModulo() ratio1= (ejeI1-ejeFuerteTeor).getModulo() ejeDebilTeor= geom.Vector2d(-math.sqrt(2)/2,math.sqrt(2)/2) ratio2= (ejeDebil-ejeDebilTeor).getModulo() ratio3= (ejeI2-ejeDebilTeor).getModulo() ''' print "Iz: ",Iz print "I1: ",I1 print "Eje 1: ",ejeI1 print "Eje fuerte: ",ejeFuerte print "Iy: ",Iy print "I2: ",I2 print "Eje 2: ",ejeI2 print "Eje debil: ",ejeDebil
# -*- coding: utf-8 -*- from __future__ import print_function import xc_base import geom import math def getAbs(vt1): return vt1.getModulus() def getAngle(vt1, vt2): return vt1.getAngle(vt2) u = geom.Vector2d(1, 0) v = geom.Vector2d(1, 1) modulus = getAbs(u) alpha = getAngle(v, u) ratio1 = modulus - 1 ratio2 = math.degrees(alpha) - 45 import os fname = os.path.basename(__file__) if math.fabs(ratio1) < 1e-10 and math.fabs(ratio2) < 1e-10: print("test ", fname, ": ok.") else: print("test ", fname, ": ERROR.")
# -*- coding: utf-8 -*- from __future__ import print_function import xc_base import geom svd1 = geom.SlidingVectorsSystem2d() ptoAplic = geom.Pos2d(1, 1) vectorDir = geom.Vector2d(1, 0) vec = geom.SlidingVector2d(ptoAplic, vectorDir) svd1 += vec ptoAplic = geom.Pos2d(1, -1) vec = geom.SlidingVector2d(ptoAplic, vectorDir) svd1 += vec zml1 = svd1.zeroMomentLine() vDir1 = zml1.getVDir() svd2 = geom.SlidingVectorsSystem2d() ptoAplic = geom.Pos2d(0, 0) vectorDir = geom.Vector2d(0, 1) vec = geom.SlidingVector2d(ptoAplic, vectorDir) svd2 += vec ptoAplic = geom.Pos2d(-1, 0) vec = geom.SlidingVector2d(ptoAplic, vectorDir) svd2 += vec zml2 = svd2.zeroMomentLine() vDir2 = zml2.getVDir() ratio = (vDir1.x - 1.0)**2 + vDir1.y**2 + vDir2.x**2 + (vDir2.y - 1.0)**2 # print('zml1= ', zml1) # print('vDir1= ', vDir1)
uTeor= 8*P*f/L**2 p0= geom.Pos2d(0,e1) p1= geom.Pos2d(L/2.0,(e1+e2)/2.0-f) p2= geom.Pos2d(L,e2) traceCable= pb.Parabola(p0,p1,p2) x= 0.0 err= 0 nPts= 5 for i in range(1,nPts+2): x= float(i-1)*L/float(nPts) alpha= traceCable.alpha(x) r= traceCable.curvature(x) Px= P/math.cos(alpha)*geom.Vector2d(math.cos(alpha),math.sin(alpha)) u= (P/math.cos(alpha))*r err+= (u-uTeor)**2 err= math.sqrt(err) #print "err= ", err import os from misc_utils import log_messages as lmsg fname= os.path.basename(__file__) if (err<0.01): print "test ",fname,": ok." else: lmsg.error(fname+' ERROR.')