Very long Refine/Solve batch run - is my code broken, or just complicated?

Question

So I'm trying to run some Mathematica code in batch mode from my university cluster. Specifically, I'm trying to find the equilibria of a system of ordinary differential equations. Inspired by the answer to my original question on the Math site, I'm using a combination of Refine and Solve for this.

Code for a simpler but related system, which runs swimmingly on either the cluster or my own machine is this:

Since then, I've tried to run this adapted code for a considerably more complicated system:

This is taking forever. In the "longer than a day, devoured all the RAM on a 48 Gb cluster node and was well on its way to eating the RAM on a 96 Gb node before I killed it" sense of the word. Which is fine if the code is actually working - it's something of a hard problem for a computer to do, and if it just takes a long time, so be it. My problem is there's also the distinct possibility I've done something wrong, created a runaway process, etc. and I'm not a good enough Mathematica programmer to spot it (I'm a rather poor Mathematica programmer in fact). Anyone able to spot anything clearly pathological about what I've done?

Edit: Adding in editable/cut-and-pasteable code. Converting between the standard form and the input form has changed the code slightly, including swapping Simplify and Solve, but I have no idea if that matters.

Refine[(Simplify[#1, \[CurlyTheta] > 0 && \[Rho]p > 0 && \[Sigma]p > 
       0 && \[Rho]d > 0 && \[Sigma]d > 0 && 
            \[Rho]a > 0 && \[Sigma]a > 0 && 
      1/\[Omega] > 0 && \[Alpha] > 0 && \[Psi]p > 0 && \[Mu]p > 0 && 
            \[Mu]a > 0 && \[Theta]p > 0 && \[Nu]up > 0 && \[Theta] > 
       0 && \[Zeta] > 0 && \[Psi]a > 0 && 
            \[Theta]a > 0 && \[Nu]ua > 0 && \[Gamma] > 0 && \[Phi] > 
       0 && \[Kappa] > 0 && \[Nu]cp > 0 && 
            \[Tau] > 0 && \[Nu]ca > 0] & )[
     Solve[{\[CurlyTheta]*H - \[Rho]p*\[Sigma]p*
       Cp*(Us/N) - \[Rho]d*\[Sigma]d*D*(Us/N)*\[Rho]a*\[Sigma]a*
       Ca*(Us/N) == 0, 
         \[Rho]p*\[Sigma]p*Cp*(Us/N) + \[Rho]d*\[Sigma]d*
       D*(Us/N)*\[Rho]a*\[Sigma]a*Ca*(Us/N) + \[CurlyTheta]*H == 0, 
         (1/\[Omega])*Ua - \[Alpha]*Up - \[Rho]p*\[Psi]p*
       Up*(H/N) - \[Mu]p*\[Sigma]p*Up*(Cp/N) - 
             \[Mu]a*\[Sigma]a*Up*(Ca/N) - \[Theta]p*
       Up + \[Nu]up*(\[Theta]*M + \[Zeta]*D) == 0, 
         \[Alpha]*Up - (1/\[Omega])*Ua - \[Rho]a*\[Psi]a*
       Ua*(H/N) - \[Mu]p*\[Sigma]p*Ua*(Cp/N) - 
             \[Mu]a*\[Sigma]a*Ua*(Ca/N) - \[Theta]a*
       Ua + \[Nu]ua*(\[Theta]*M + \[Zeta]*D) == 0, 
         (1/\[Omega])*Ca + \[Gamma]*\[Phi]*D + \[Rho]p*\[Psi]p*
       Up*(H/N) + \[Mu]p*\[Sigma]p*Up*(Cp/N) + 
             \[Mu]a*\[Sigma]a*Up*(Ca/N) - \[Alpha]*Cp - \[Kappa]*
       Cp - \[Theta]p*Cp + \[Nu]cp*(\[Theta]*M + \[Zeta]*D) == 0, 
         \[Alpha]*Cp + \[Gamma]*(1 - \[Phi])*D + \[Rho]a*\[Psi]a*
       Ua*(H/N) + \[Mu]p*\[Sigma]p*Ua*(Cp/N) + 
             \[Mu]a*\[Sigma]a*Ua*(Ca/N) - (1/\[Omega])*
       Ca - \[Kappa]*\[Tau]*Ca - \[Theta]a*Ca + 
             \[Nu]ca*(\[Theta]*M + \[Zeta]*D) == 
     0, \[Kappa]*Cp + \[Kappa]*\[Tau]*Ca - \[Gamma]*\[Phi]*
       D - \[Gamma]*(1 - \[Phi])*D - 
             \[Zeta]*D + \[Nu]d*(\[Theta]*M + \[Zeta]*D) == 0, 
    Us + H + Up + Ua + Cp + Ca + D == 0, 
         Up + Ua + Cp + Ca + D == 0}, {Us, H, Up, Ua, Cp, Ca, D, N, 
    M}, Reals]], Null]

Update

Per some suggestions below, am now trying the following:

Solve[{\[CurlyTheta]*H - \[Rho]p*\[Sigma]p*
     Cp*(Us/N) - \[Rho]d*\[Sigma]d*D*(Us/N)*\[Rho]a*\[Sigma]a*
     Ca*(Us/N) == 
   0, \[Rho]p*\[Sigma]p*Cp*(Us/N) + \[Rho]d*\[Sigma]d*
     D*(Us/N)*\[Rho]a*\[Sigma]a*Ca*(Us/N) + \[CurlyTheta]*H == 
   0, (1/\[Omega])*Ua - \[Alpha]*Up - \[Rho]p*\[Psi]p*
     Up*(H/N) - \[Mu]p*\[Sigma]p*Up*(Cp/N) - \[Mu]a*\[Sigma]a*
     Up*(Ca/N) - \[Theta]p*Up + \[Nu]up*(\[Theta]*M + \[Zeta]*D) == 
   0, \[Alpha]*Up - (1/\[Omega])*Ua - \[Rho]a*\[Psi]a*
     Ua*(H/N) - \[Mu]p*\[Sigma]p*Ua*(Cp/N) - \[Mu]a*\[Sigma]a*
     Ua*(Ca/N) - \[Theta]a*Ua + \[Nu]ua*(\[Theta]*M + \[Zeta]*D) == 
   0, (1/\[Omega])*Ca + \[Gamma]*\[Phi]*D + \[Rho]p*\[Psi]p*
     Up*(H/N) + \[Mu]p*\[Sigma]p*Up*(Cp/N) + \[Mu]a*\[Sigma]a*
     Up*(Ca/N) - \[Alpha]*Cp - \[Kappa]*Cp - \[Theta]p*
     Cp + \[Nu]cp*(\[Theta]*M + \[Zeta]*D) == 
   0, \[Alpha]*Cp + \[Gamma]*(1 - \[Phi])*D + \[Rho]a*\[Psi]a*
     Ua*(H/N) + \[Mu]p*\[Sigma]p*Ua*(Cp/N) + \[Mu]a*\[Sigma]a*
     Ua*(Ca/N) - (1/\[Omega])*Ca - \[Kappa]*\[Tau]*Ca - \[Theta]a*
     Ca + \[Nu]ca*(\[Theta]*M + \[Zeta]*D) == 
   0, \[Kappa]*Cp + \[Kappa]*\[Tau]*Ca - \[Gamma]*\[Phi]*
     D - \[Gamma]*(1 - \[Phi])*D - \[Zeta]*
     D + \[Nu]d*(\[Theta]*M + \[Zeta]*D) == 0, 
  N == Us + H + Up + Ua + Cp + Ca + D, 
  M == Up + Ua + Cp + Ca + D , \[CurlyTheta] > 0, \[Rho]p > 
   0, \[Sigma]p > 0, \[Rho]d > 0, \[Sigma]d > 0, \[Rho]a > 
   0, \[Sigma]a > 0, \[Omega] > 0, \[Alpha] > 0, \[Psi]p > 0, \[Mu]p >
    0, \[Mu]a > 0, \[Theta]p > 0, \[Nu]up > 0, \[Theta] > 0, \[Zeta] >
    0, \[Psi]a > 0, \[Theta]a > 0, \[Nu]ua > 0, \[Gamma] > 0, \[Phi] >
    0, \[Kappa] > 0, \[Tau] > 0, \[Nu]ca > 0, \[Nu]d > 0}, {Us, H, Up,
   Ua, Cp, Ca, D, N, M}, Reals]

It hasn't immediately solved the problem (let it run for ~hour on a local machine), but sending it to the cluster to see if it gets fixed.

Answer 1

I've found with some of my own code that putting in the simplifying equations INTO the solve function speeds things up (sometimes significantly, in the "I don't know if this is going to finish" -> seconds timeframe). That is, instead of writing:

Solve[{EquationToSolve==0},{a,b,c}]//Simplify[#,a>0 && b<0 && c>=0]

Write

Solve[{EquationToSolve==0, a>0, b<0, c>=0},{a,b,c}]

I think this has something to do with Mathematica trying to simplify things immediately as it finds solutions, and since it can start simplifying early, the final answer turns out much faster.

Obviously this is not useful if you're looking for a general solution, but in many cases you can look at many more "specific" solutions in the same amount of time it would take you to solve for the general one.

Answer 2

Might try without the inequalities and Reals domain specification. For one thing, they are not sll that helpful when there are free parameters that can take values in a large range. For another, you will ahve a better chance of it not hanging your machine. (By "better" I don't mean "guaranteed". No promises on this one.)

Of course if you do get solutions, you will then need to figure out which ones are viable for your inequality purposes.