## Restrict on arguments ##
As others have mentioned replacing all functions with arguments with just their names wouldn't leave you with something very useful, so you have to make some restrictions. It has been shown how you can restrict for which functions such replacements should be made. What I would like to add is the possibility to make such redefinitions only for certain kinds of arguments. This could be as simple as:

    eqn = Subscript[R, tt\[Phi]]^\[Phi] == 
       D[\[Xi][r, z], r] D[\[Xi][r, z], 
         z] Exp[4 \[Psi][r, z] - 2 \[Nu][r, z]]/\[Xi][r, z];
    (eqn // pdConv) /. {f_[r, z] :> f}

for the example you gave. 


## Formal Parameters ##
A feature that is available since Mathematica 7 are special names for "formal parameters" which are `Protected` so you can be reasonably sure they won't have values. I think it's just such formula type expressions as yours that these were introduced, so you might want to use them for your arguments. If you do so you could make this approach somewhat more general: First define the helper function:


    formalQ[___] = False;
    formalQ[x_Symbol] := StringMatchQ[
       ToString[x, CharacterEncoding -> "ASCII"], "\\[Formal" ~~ __
       ];

and then define your expressions using those formal parameters (which you can enter with e.g. <kbd>Esc</kbd>-$-x-<kbd>Esc</kbd>).

    eqn = Subscript[R, tt\[Phi]]^\[Phi] == 
       D[\[Xi][\[FormalR], \[FormalZ]], \[FormalR]] D[\[Xi][\[FormalR], \
    \[FormalZ]], \[FormalZ]] Exp[
          4 \[Psi][\[FormalR], \[FormalZ]] - 
           2 \[Nu][\[FormalR], \[FormalZ]]]/\[Xi][\[FormalR], \[FormalZ]];

and now use something like this to get the desired simplification:

    (eqn // pdConv) /. {f_[__?formalQ] /; Context[f] =!= "System`" :> f}


## Interpretation ##
Another thing I would like to mention is that you could make your results look the way you want but still evaluate correctly by using `Interpretation`. The following does this for a combination of `pdConv`, the above replacement and some additional formatting so one can immediately see which of the variables are actually functions with left out parameters:

    formatEqn[expr_] := Interpretation[TraditionalForm[
        expr /. {
           Derivative[inds__][g_][vars__] :> Interpretation[Apply[
              HoldForm[D[g[vars], ##]] &, Transpose[{{vars}, {inds}}] /. {
                {var_, 0} :> Sequence[],
                {var_, 1} :> {var}
                }],
             Derivative[inds][g][vars]]
           } /. {
          \[FormalF]_Symbol[\[FormalA]__?formalQ] /; 
            Context[\[FormalF]] =!= "System`" -> 
           Interpretation[
            Style[\[FormalF], RGBColor[0, 0.6, 0], 
             Bold], \[FormalF][\[FormalA]]]
          }
        ],
       expr
       ];
    
You should now be able to copy the result (or parts of it), paste to a new input cell and evaluate that new cell. It would also be possible to programmatically do further work with the result given above with something like this:


    formattedEqn = eqn // formatEqn
    (ToExpression[ToBoxes[formattedEqn]] /. \[Xi]->Function[Sin[#1]*Cos[#2]])// formatEqn

I'm guess that this will not exactly match your needs but think with this and the information others gave and some further reading of the documentation of the functions used/mentioned above you should be well prepared to exactly build what you need...