docs: def predictPhenos(self,use_fixed=None,use_random=None):
          """
          predict the conditional mean (BLUP)
  
          Args:
              use_fixed:        list of fixed effect indeces to use for predictions
              use_random:        list of random effect indeces to use for predictions
          Returns:
              predictions (BLUP)
          """
          assert self.noisPos is not None,      'No noise element'
          assert self.init,               'GP not initialised'
          assert self.Ntest is not None,        'VarianceDecomposition:: specify Ntest for predictions (method VarianceDecomposition::setTestSampleSize)'
  
          use_fixed  = list(range(self.n_fixedEffs))
          use_random = list(range(self.n_randEffs))
  
          KiY = self.gp.agetKEffInvYCache()
  
          if self.fast==False:
              KiY = KiY.reshape(self.P,self.N).T
  
          Ypred = sp.zeros((self.Ntest,self.P))
  
          # predicting from random effects
          for term_i in use_random:
              if term_i!=self.noisPos:
                  Kstar = self.Kstar[term_i]
                  if Kstar is None:
                      warnings.warn('warning: random effect term %d not used for predictions as it has None cross covariance'%term_i)
                      continue
                  term  = sp.dot(Kstar.T,KiY)
                  if self.P>1:
                      C    = self.getTraitCovar(term_i)
                      term = sp.dot(term,C)
                  else:
                      term *= self.getVarianceComps()[0,term_i]
                  Ypred += term
  
          # predicting from fixed effects
          weights = self.getWeights()
          w_i = 0
          for term_i in use_fixed:
              Fstar = self.Fstar[term_i]
              if Fstar is None:
                  warnings.warn('warning: fixed effect term %d not used for predictions as it has None test sample design'%term_i)
                  continue
              if self.P==1:    A = sp.eye(1)
              else:            A = self.vd.getDesign(term_i)
              Fstar = self.Fstar[term_i]
              W = weights[w_i:w_i+A.shape[0],0:1].T
              term = sp.dot(Fstar,sp.dot(W,A))
              w_i += A.shape[0]
              Ypred += term
  
          return Ypred