def solve(self,loadCaseName,loadCaseExpr=''):
     self.loadCaseName=loadCaseName
     self.loadCaseExpr=loadCaseExpr
     preprocessor= self.feProblem.getPreprocessor
     combs=preprocessor.getLoadHandler.getLoadCombinations
     lCase=combs.newLoadCombination(self.loadCaseName,self.loadCaseExpr)
     preprocessor.resetLoadCase()
     combs.addToDomain(self.loadCaseName)
     #Solution
     analysis= predefined_solutions.simple_static_linear(self.feProblem)
     result= analysis.analyze(1)
     combs.removeFromDomain(self.loadCaseName)

def resuelveCombEstatLin(comb):
  preprocessor.resetLoadCase()
  previa= comb.getCombPrevia()
  if(previa!=None):
    nombrePrevia= previa.getName
    tagPrevia= previa.tag
    ''' 
    print "nombrePrevia= ",nombrePrevia
    print "tag= ",comb.tag
    print "tagPrevia= ",tagPrevia
    print "descomp previa= ",getDescompCombPrevia
    print "resto sobre previa= ",getDescompRestoSobrePrevia
    '''
    tagSave= tagPrevia*100
    if(tagPrevia>0):
      db.restore(tagSave)

    comb.addToDomain()
    analisis= predefined_solutions.simple_static_linear(feProblem)
    result= analisis.analyze(1)
    comb.removeFromDomain()

lPatterns= loadHandler.getLoadPatterns

#Load modulation.
ts= lPatterns.newTimeSeries("constant_ts","ts")
lPatterns.currentTimeSeries= "ts"
#Load case definition
lp0= lPatterns.newLoadPattern("default","0")
lp0.newNodalLoad(2,xc.Vector([0,0,F,0,0,0]))
lp0.newNodalLoad(3,xc.Vector([0,0,F,0,0,0]))
#We add the load case to domain.
lPatterns.addToDomain("0")



# Solution
analisis= predefined_solutions.simple_static_linear(feProblem)
result= analisis.analyze(1)


q13MedioElem= 0.0
q23MedioElem= 0.0
elem.getResistingForce()
mats= elem.getPhysicalProperties.getVectorMaterials #Materials at gauss points.
#Gauss points iterator
for m in mats:
  q13MedioElem= q13MedioElem+m.getStressResultantComponent("q13")
  q23MedioElem= q23MedioElem+m.getStressResultantComponent("q23")

q13MedioElem= q13MedioElem/4
q23MedioElem= q23MedioElem/4

elementos= prep.getElementHandler
        \for_each

            .vector3dEdgeLoadGlobal(xc.ID(3,2),xc.Vector(0,p,0))
            .vector3dEdgeLoadGlobal(xc.ID(4,1),xc.Vector(0,p,0))


cargas= prep.getLoadHandler

casos= cargas.getLoadPatterns{#We add the load case to domain.
casos.addToDomain("0")


#Solución
analisis= predefined_solutions.simple_static_linear(prueba)
result= analisis.analyze(1)


        nodos.calculateNodalReactions(True)
nodos= prep.getNodeHandler

 RNX1= .getReaction[0] RNY1= nodos.getNode(1).getReaction[1] RNZ1= .getReaction[2] \expr{MX1= .getReaction[3] 
 RNX2= .getReaction[0] RNY2= nodos.getNode(2).getReaction[1] RNZ2= .getReaction[2] \expr{MX2= .getReaction[3] 




RTeor= -p*L

ratio1= (abs((RNX1+RNX2)/RTeor))

'''
# Loads definition
cargas= prep.getLoadHandler
casos= cargas.getLoadPatterns
#Load modulation.
ts= casos.newTimeSeries("constant_ts","ts")
casos.currentTimeSeries= "ts"
#Load case definition
lp0= casos.newLoadPattern("default","0")
casos.currentLoadPattern='0'
#We add the load case to domain.
casos.addToDomain('0')

# Phase 1: prestressing of tendon
# Solution procedure
analisis= predefined_solutions.simple_static_linear(FEcase)
analOk= analisis.analyze(1)
uz_ph1=msNod.getDisp[2]

# Phase 2: self weight
loadVector=xc.Vector([0,0,-Wsw])
for e in beamSet.getElements:
    e.vector3dUniformLoadGlobal(loadVector)
analOk= analisis.analyze(1)
uz_ph2=msNod.getDisp[2]

# Phase 3: prestress loss in service
for e in tendonSet.getElements:
    tendonMat= e.getMaterial()
    tendonMat.prestress= fps
    e.update() #Update element state according with the new prestress

def defaultAnalysis(feProb,steps= 1):
    '''Default analysis procedure for saveAll method.'''
    analysis= predefined_solutions.simple_static_linear(feProb)
    result= analysis.analyze(steps) #Same with the number of steps.
    return result