source: trunk/anuga_work/development/2010-projects/anuga_1d/sqpipe/sqpipe_dual_fixed_width_a_d.h @ 8236

#include "sqpipe.h"

/**********************************************************
Square pipe dual fixed width quantity class
**********************************************************/

struct sqpipe_dual_fixed_width_a_d_quantity {
  struct sqpipe_quantity super;
  long state;
};

// Construction
void sqpipe_dual_fixed_width_a_d_quantity_init (struct sqpipe_dual_fixed_width_a_d_quantity *q);
struct sqpipe_dual_fixed_width_a_d_quantity *sqpipe_dual_fixed_width_a_d_quantity_new();

// Destruction

// Methods
double* sqpipe_dual_fixed_width_a_d_quantity_flux_formula (struct quantity *q, double normal, struct params *p, double *quantityflux);
double sqpipe_dual_fixed_width_a_d_quantity_sound_speed (struct quantity *q, struct params *p);
double sqpipe_dual_fixed_width_a_d_quantity_get_conserved (struct quantity *q, int k, double normal);

// Implementation
double* sqpipe_dual_fixed_width_a_d_quantity_flux_formula (struct quantity *q, double normal, struct params *p, double *quantityflux) {
  if (((struct sqpipe_dual_fixed_width_a_d_quantity *)q)->state == 0) {
    return sqpipe_quantity_free_surface_flux_formula(q, normal, p, quantityflux);
  } else {
    return sqpipe_quantity_pressurised_flux_formula(q, normal, p, quantityflux);
  }
}

double sqpipe_dual_fixed_width_a_d_quantity_sound_speed (struct quantity *q, struct params *p) {
  if (((struct sqpipe_dual_fixed_width_a_d_quantity *)q)->state == 0) {
    return sqpipe_quantity_free_surface_sound_speed(q, p);
  } else {
    return sqpipe_quantity_pressurised_sound_speed(q, p);
  }
}

double sqpipe_dual_fixed_width_a_d_quantity_get_conserved (struct quantity *q, int k, double normal) {
  struct sqpipe_quantity *p = (struct sqpipe_quantity*) q;
  double c;
  
  switch (k) {
  case 0:
    c = p->a;
    break;
  case 1:
    // This should be normal^2 p->d and normal is +/- 1
    c = p->d;
    break;
  default:
    c = 0;
  }
  return c;
}

void sqpipe_dual_fixed_width_a_d_quantity_init (struct sqpipe_dual_fixed_width_a_d_quantity *q) {
  struct sqpipe_quantity *p = (struct sqpipe_quantity *)q;

  sqpipe_quantity_init(p);

  static struct quantity_vtable vtable = {
    &sqpipe_dual_fixed_width_a_d_quantity_flux_formula,
    &sqpipe_dual_fixed_width_a_d_quantity_sound_speed,
    &sqpipe_dual_fixed_width_a_d_quantity_get_conserved,
    &sqpipe_quantity_destroy
  };
  p->super.vtable = &vtable;

  ((struct sqpipe_dual_fixed_width_a_d_quantity *)p)->state = 0;
}

struct sqpipe_dual_fixed_width_a_d_quantity *sqpipe_dual_fixed_width_a_d_quantity_new() {
  struct sqpipe_dual_fixed_width_a_d_quantity *p = malloc(sizeof(struct sqpipe_dual_fixed_width_a_d_quantity));

  sqpipe_dual_fixed_width_a_d_quantity_init(p);

  return p;
}
/**********************************************************/


/**********************************************************
Square pipe dual fixed width edge class
**********************************************************/
struct sqpipe_dual_fixed_width_a_d_edge {
  struct sqpipe_edge super;
};

// Construction
void sqpipe_dual_fixed_width_a_d_edge_init (struct sqpipe_dual_fixed_width_a_d_edge *e);
struct sqpipe_dual_fixed_width_a_d_edge *sqpipe_dual_fixed_width_a_d_edge_new();

// Destruction

// Methods

// Implementation

void sqpipe_dual_fixed_width_a_d_edge_init (struct sqpipe_dual_fixed_width_a_d_edge *q) {
  sqpipe_edge_init((struct sqpipe_edge *)q);
}

struct sqpipe_dual_fixed_width_a_d_edge *sqpipe_dual_fixed_width_a_d_edge_new() {
  struct sqpipe_dual_fixed_width_a_d_edge *e = (struct sqpipe_dual_fixed_width_a_d_edge *) sqpipe_edge_new();

  sqpipe_dual_fixed_width_a_d_edge_init(e);

  // Create inner and outer quantities
  ((struct edge *)e)->qin = (struct quantity *)sqpipe_dual_fixed_width_a_d_quantity_new();
  ((struct edge *)e)->qout = (struct quantity *)sqpipe_dual_fixed_width_a_d_quantity_new();
  
  return e;
}
/**********************************************************/


/**********************************************************
Square pipe dual fixed width cell class
**********************************************************/
struct sqpipe_dual_fixed_width_a_d_cell {
  struct sqpipe_cell super;

  long state;
};

// Construction
void sqpipe_dual_fixed_width_a_d_cell_init (struct sqpipe_dual_fixed_width_a_d_cell *e);
struct sqpipe_dual_fixed_width_a_d_cell *sqpipe_dual_fixed_width_a_d_cell_new();

// Destruction

// Methods
double* sqpipe_dual_fixed_width_a_d_cell_forcing_terms (struct cell *c, struct params *p, double *cellforce);

// Implementation
double* sqpipe_dual_fixed_width_a_d_cell_forcing_terms (struct cell *c, struct params *p, double *cellforce) {
  if (((struct sqpipe_dual_fixed_width_a_d_cell *)c)->state == 0) {
    return sqpipe_cell_free_surface_forcing_terms(c, p, cellforce);    
  } else {
    return sqpipe_cell_pressurised_forcing_terms(c, p, cellforce);
  }
}

void sqpipe_dual_fixed_width_a_d_cell_init (struct sqpipe_dual_fixed_width_a_d_cell *q) {
  struct sqpipe_cell *p = (struct sqpipe_cell *) q;

  sqpipe_cell_init(p);

  static struct cell_vtable vtable = {
    &cell_flux_function_generic,
    &sqpipe_cell_extreme_sound_speeds,
    &sqpipe_dual_fixed_width_a_d_cell_forcing_terms,
    &sqpipe_cell_destroy
  };
  p->super.vtable = &vtable;

  ((struct sqpipe_dual_fixed_width_a_d_cell *)p)->state = 0;
}

struct sqpipe_dual_fixed_width_a_d_cell *sqpipe_dual_fixed_width_a_d_cell_new() {
  int i;
  struct sqpipe_dual_fixed_width_a_d_cell *c = malloc(sizeof(struct sqpipe_dual_fixed_width_a_d_cell));

  // Allocate memory for a length 2 array of pointers to edges
  ((struct cell *)c)->edges = (struct edge  **) malloc(2 * sizeof(struct sqpipe_edge *));

  sqpipe_dual_fixed_width_a_d_cell_init(c);

  // Create edges
  for (i=0; i<((struct cell *)c)->num_edges; i++) {
    ((struct cell *)c)->edges[i] = (struct edge *) sqpipe_dual_fixed_width_a_d_edge_new();
  }

  return c;
}
/**********************************************************/


/**********************************************************
Square pipe dual fixed width quantities class
**********************************************************/
struct sqpipe_dual_fixed_width_a_d_quantities {
  struct sqpipe_quantities super;
};

// Construction
void sqpipe_dual_fixed_width_a_d_quantities_init (struct sqpipe_dual_fixed_width_a_d_quantities *q);
struct sqpipe_dual_fixed_width_a_d_quantities *sqpipe_dual_fixed_width_a_d_quantities_new();

// Destruction

// Methods
void sqpipe_dual_fixed_width_a_d_quantities_update (struct quantities *qs, double *flux, int k);


// Implementation
void sqpipe_dual_fixed_width_a_d_quantities_update (struct quantities *qs, double *flux, int k) {
  struct sqpipe_quantities *ps = (struct sqpipe_quantities *) qs;
  ps->a[k] = flux[0];
  ps->d[k] = flux[1];
}

void sqpipe_dual_fixed_width_a_d_quantities_init (struct sqpipe_dual_fixed_width_a_d_quantities *q) {
  struct sqpipe_quantities *p = (struct sqpipe_quantities *)q;

  sqpipe_quantities_init(p);

  static struct quantities_vtable vtable = {
    &sqpipe_quantities_get_quantity,
    &sqpipe_dual_fixed_width_a_d_quantities_update,
    &sqpipe_quantities_destroy
  };
  p->super.vtable = &vtable;
}

struct sqpipe_dual_fixed_width_a_d_quantities *sqpipe_dual_fixed_width_a_d_quantities_new() {
  struct sqpipe_dual_fixed_width_a_d_quantities *p = (struct sqpipe_dual_fixed_width_a_d_quantities *) sqpipe_quantities_new();

  sqpipe_dual_fixed_width_a_d_quantities_init(p);

  return p;
}
/**********************************************************/


/**********************************************************
Square pipe free surface fixed width domain class
**********************************************************/

struct sqpipe_dual_fixed_width_a_d_domain {
  struct sqpipe_domain super;
  long *state;
};

// Construction
void sqpipe_dual_fixed_width_a_d_domain_init (struct sqpipe_dual_fixed_width_a_d_domain *d);
struct sqpipe_dual_fixed_width_a_d_domain *sqpipe_dual_fixed_width_a_d_domain_new();

// Destruction

// Methods
struct edge* sqpipe_dual_fixed_width_a_d_domain_new_edge(struct domain *d);
struct cell* sqpipe_dual_fixed_width_a_d_domain_new_cell(struct domain *d);
struct cell* sqpipe_dual_fixed_width_a_d_domain_get_cell(struct domain *D, int k, struct cell *c);

// Implementation
struct edge* sqpipe_dual_fixed_width_a_d_domain_new_edge(struct domain *d) {
  struct edge *e = (struct edge*) sqpipe_dual_fixed_width_a_d_edge_new();

  return e;
}

struct cell* sqpipe_dual_fixed_width_a_d_domain_new_cell(struct domain *d) {
  struct cell *c = (struct cell*) sqpipe_dual_fixed_width_a_d_cell_new();
  return c;
}

struct cell* sqpipe_dual_fixed_width_a_d_domain_get_cell(struct domain *D, int k, struct cell *c) {
  struct sqpipe_dual_fixed_width_a_d_cell *sc = (struct sqpipe_dual_fixed_width_a_d_cell *) c;
  struct sqpipe_dual_fixed_width_a_d_domain *sD = (struct sqpipe_dual_fixed_width_a_d_domain *) D;
  int i;
  
  c = domain_get_cell_generic(D, k, c);

  // Set state
  sc->state = sD->state[k];
  for (i = 0; i<c->num_edges; i++) {
    ((struct sqpipe_dual_fixed_width_a_d_quantity *)(c->edges[i]->qin))->state = sc->state;
    ((struct sqpipe_dual_fixed_width_a_d_quantity *)(c->edges[i]->qout))->state = sc->state;
  }
  
  return c;
}

void sqpipe_dual_fixed_width_a_d_domain_init (struct sqpipe_dual_fixed_width_a_d_domain *d) {
  struct sqpipe_domain *p = (struct sqpipe_domain *)d;

  sqpipe_domain_init(p);

  static struct domain_vtable vtable = {
    &sqpipe_dual_fixed_width_a_d_domain_new_edge,
    &sqpipe_dual_fixed_width_a_d_domain_new_cell,
    &domain_compute_fluxes_generic,
    &sqpipe_dual_fixed_width_a_d_domain_get_cell,
    &sqpipe_domain_destroy
  };
  p->super.vtable = &vtable;

  ((struct sqpipe_dual_fixed_width_a_d_domain *)p)->state = NULL;
}

struct sqpipe_dual_fixed_width_a_d_domain *sqpipe_dual_fixed_width_a_d_domain_new() {
  struct sqpipe_dual_fixed_width_a_d_domain *d = (struct sqpipe_dual_fixed_width_a_d_domain *) sqpipe_domain_new();

  sqpipe_dual_fixed_width_a_d_domain_init(d);

  ((struct domain *) d)->vertex_values = (struct quantities *) sqpipe_dual_fixed_width_a_d_quantities_new();
  ((struct domain *) d)->boundary_values = (struct quantities *) sqpipe_dual_fixed_width_a_d_quantities_new();
  ((struct domain *) d)->explicit_update = (struct quantities *) sqpipe_dual_fixed_width_a_d_quantities_new();

  return d;
}
/**********************************************************/