class DiverseEcosystem extends Ecosystem {
  // utilities for making an allometrically or stochastically diverse ecosystem.
  // ASTroCAT 1.0 doesn't take advantage of the stochasticity part (except for prey prefs, where stochasticity is introduced by another mechanism anyway).
  
  DiverseEcosystem() {}

  // arrays of diverse statevars
  
  DiverseVar[] addDiverseVarSet(String name, String shortname, String units, int N, float minEsd, float maxEsd) {
    DiverseVar[] V = new DiverseVar[N];
    for (int i=0; i<N; i++) {
      float esd = exp(map(i, 0, N-1, log(minEsd), log(maxEsd)));
      V[i] = new DiverseVar(name + "-" + i, shortname + "-" + i, units, Ncells, esd);
      V[i].advects = true;
      V[i].mixes = true;
      V[i].sinks = false;
      V[i].min = 0;
      vars = (Statevar[])append(vars,V[i]);
      V[i].hidden = false;
    }
    return V;
  }

  // arrays of fluxes

  Flux[] addFluxSet(String name, String shortname, Statevar[] from, Statevar to) {
    Flux[] F = new Flux[from.length];
    for (int i=0; i<F.length; i++) F[i] = addFlux(name + "-" + i, shortname + "-" + i, from[i], to);
    return F;
  }

  Flux[] addFluxSet(String name, String shortname, Statevar from, Statevar[] to) {
    Flux[] F = new Flux[to.length];
    for (int i=0; i<F.length; i++) F[i] = addFlux(name + "-" + i, shortname + "-" + i, from, to[i]);
    return F;    
  }

  Flux[][] addFluxSet2D(String name, String shortname, Statevar from[], Statevar[] to) {
    Flux[][] F = new Flux[from.length][to.length];
    for (int i=0; i<from.length; i++) {
      for (int j=0; j<to.length; j++) {
        F[i][j] = addFlux(name + "-" + i + "-" + j, shortname + "-" + i + "-" + j, from[i], to[j]);
      }
    }
    return F;    
  }

  // diverse params
  
  DiverseParam addDiverseParam(String name, String shortname, String units, float initial, float min, float max, float randLogStd) {
    return addDiverseParam(name,shortname,units,initial,min,max,randLogStd,1,0);
  }
  
  DiverseParam addDiverseParam(String name, String shortname, String units, float initial, float min, float max, float randLogStd, float alloScaleSize, float alloExp) {
    DiverseParam P = new DiverseParam(name,shortname,units,initial,min,max,randLogStd,alloScaleSize,alloExp);
    params = (FreeParam[])append(params,P);
    return P;
  }

  float getCurrent(FreeParam P, Statevar V) {
    if (P instanceof DiverseParam && V instanceof DiverseVar) {
      return getCurrent((DiverseParam)P, (DiverseVar)V);
    } else {
      return P.current;
    }
  }
  
  float getCurrent(DiverseParam P, DiverseVar V) { // gets the current value of P appropriate to the statevar V, taking into account random variation and allometry
    float val = P.current; // no allometry, no randomness yet
    if (P.doAllo) val *= pow(V.esd / P.alloScaleSize, P.alloExp); // apply allometry
    val *= pow(P.randLogStd, P.randMultiplier * randn(P.randSignature,V.randSignature)); // apply randomness
    val = constrain(val, P.min, P.max);
    return val;
  }
  
  float[] getCurrent(FreeParam P, Statevar[] V) {
    float[] val = new float[V.length];
    for (int i=0; i<val.length; i++) val[i] = getCurrent(P, V[i]);
    return val;
  }
  
  void reseed() {
    for (int i=0; i<vars.length; i++) {
      if (vars[i] instanceof DiverseVar) ((DiverseVar)vars[i]).reseed();
    }
    for (int i=0; i<params.length; i++) {
      if (params[i] instanceof DiverseParam) ((DiverseParam)params[i]).reseed();
    }
  }
      
}




// ------------------------------------------------------------------------------------




class DiverseVar extends Statevar { // stores a size (esd) and a random signature
  
  float esd = 1;
  float randSignature = random(1);
  
  DiverseVar(String name, String shortname, String units, float esd) {
    this.name = name;
    this.shortname = shortname;
    this.units = units;
    this.esd = esd;
  }

  DiverseVar(String name, String shortname, String units, int N, float esd) {
    this.name = name;
    this.shortname = shortname;
    this.units = units;
    allocate(N);
    this.esd = esd;
  }
  
  void reseed() {
    randSignature = random(1);
  }
    
}


// ------------------------------------------------------------------------------------------


class DiverseParam extends FreeParam { // stores a random signature and a specification of an allometric curve
  
  float randSignature = random(1);
  float randLogStd = 0; // std dev of the random distribution of log values around the allometric central tendency, in data units
  // min and max are constraints on allowable values (e.g., min=0 to keep growth rates from going negative), not related to the scale for random variation
  float alloScaleSize = 1; // for allometry, min max initial current are all values at this ESD
  float alloExp = 0; // exponent in the allometric power law:    rate = (ESD/alloScaleSize)^alloExp
  
  float randMultiplier = 1; // multiplies randLogStd. Use this to turn stochasticity down or off without losing the record of the intrinsic scale of variation
  boolean doAllo = true;
  
  DiverseParam(String name, String shortname, String units, float initial, float min, float max, float randLogStd) {
    construct(name, shortname, units, initial, min, max);
    this.randLogStd = randLogStd;
  }

  DiverseParam(String name, String shortname, String units, float initial, float min, float max, float randLogStd, float alloScaleSize, float alloExp) {
    construct(name, shortname, units, initial, min, max);
    this.randLogStd = randLogStd;
    this.alloScaleSize = alloScaleSize;
    this.alloExp = alloExp;
  }
  
  void reseed() {
    randSignature = random(1);
  }
  
}



// ------------------------------------------------------------------------------------------



class DiverseNetworkView extends NetworkView {
  
  DiverseNetworkView() {}  

  Dot[] addDotSet_polar(Statevar[] V, float Rmin, float Rmax, float theta, color col) {
    Dot[] D = new Dot[V.length];
    for (int i=0; i<V.length; i++) {
      D[i] = addDot_polar(V[i], map(i, 0, V.length-1, Rmin, Rmax), theta, col);
    }
    return D;
  }

  Arrow[] addArrowSet(Flux[] F, color col, float angle) {
    Arrow[] A = new Arrow[F.length];
    for (int i=0; i<F.length; i++) {
      A[i] = addArrow(F[i], col, angle);
    }
    return A;
  }
  
  Arrow[] addArrowSet(Flux[] F, float dx, float dy, color col, float angle) {
    Arrow[] A = new Arrow[F.length];
    for (int i=0; i<F.length; i++) {
      A[i] = addArrow(F[i], dx, dy, col, angle);
    }
    return A;
  }

  Arrow[] addArrowSet(Flux[][] F, color col, float angle) {
    Arrow[] A = new Arrow[F.length * F[0].length];
    int ind = 0;
    for (int i=0; i<F.length; i++) {
      for (int j=0; j<F[0].length; j++) {
        A[ind] = addArrow(F[i][j], col, angle);
        ind++;
      }
    }
    return A;
  }
  
}