FPPowerSystem3BusComputeCFL.c File Reference

Function to compute the maximum CFL for the FPPowerSystem3Bus system. More...

#include <stdlib.h>
#include <basic.h>
#include <mathfunctions.h>
#include <arrayfunctions.h>
#include <physicalmodels/fppowersystem3bus.h>
#include <mpivars.h>
#include <hypar.h>

Go to the source code of this file.

Functions
int	FPPowerSystem3BusDriftFunction (int, void *, double *, double, double *)
double	FPPowerSystem3BusComputeCFL (void *s, void *m, double dt, double t)

Detailed Description

Function to compute the maximum CFL for the FPPowerSystem3Bus system.

Author

Debojyoti Ghosh

Definition in file FPPowerSystem3BusComputeCFL.c.

Function Documentation

int FPPowerSystem3BusDriftFunction	(	int	dir,
		void *	p,
		double *	x,
		double	t,
		double *	drift
	)

Compute the drift (advection) coefficients for the 3-bus power system

Parameters

dir	Spatial dimension (not used)
p	Object of type FPPowerSystem3Bus
x	Spatial coordinates
t	Current simulation time
drift	Array to hold the drift velocities

Definition at line 76 of file FPPowerSystem3BusFunctions.c.

{
  FPPowerSystem3Bus *params = (FPPowerSystem3Bus*) p;

  double theta1 = x[0];
  double theta2 = x[1];
  double Omega1 = x[2];
  double Omega2 = x[3];
  
  double omegaB     = params->omegaB;
  double Pm1_avg    = params->Pm1_avg;
  double Pm2_avg    = params->Pm2_avg;
  double Pmref_avg  = params->Pmref_avg;
  double H1         = params->H1;
  double H2         = params->H2;
  double Href       = params->Href;
  double gamma      = params->gamma;
  
  double Pe1, Pe2, Peref;
  ComputeElectricalPower(theta1,theta2,params,&Pe1,&Pe2,&Peref);

  double F1 = Pm1_avg / (2*H1) - Pmref_avg / (2*Href);
  double F2 = Pm2_avg / (2*H2) - Pmref_avg / (2*Href);
  double S1 = Pe1 / (2*H1) - Peref / (2*Href);
  double S2 = Pe2 / (2*H2) - Peref / (2*Href);

  drift[0] = omegaB * Omega1;
  drift[1] = omegaB * Omega2;
  drift[2] = F1 - gamma*Omega1 - S1;
  drift[3] = F2 - gamma*Omega2 - S2;

  return(0);
}

double FPPowerSystem3BusComputeCFL	(	void *	s,
		void *	m,
		double	dt,
		double	t
	)

Computes the maximum CFL number over the domain. Note that the CFL is computed over the local domain on this processor only.

Parameters

s	Solver object of type HyPar
m	MPI object of type MPIVariables
dt	Time step size for which to compute the CFL
t	Time

Definition at line 19 of file FPPowerSystem3BusComputeCFL.c.

{
  HyPar             *solver = (HyPar*)              s;
  FPPowerSystem3Bus *params = (FPPowerSystem3Bus*)  solver->physics;

  int     ndims  = solver->ndims;
  int     ghosts = solver->ghosts;
  int     *dim   = solver->dim_local;

  double  max_cfl = 0;
  int     index[ndims];
  int done = 0; _ArraySetValue_(index,ndims,0);
  while (!done) {
    double x[ndims], dxinv[ndims], drift[ndims];
    _GetCoordinate_(0,index[0],dim,ghosts,solver->x,x[0]);
    _GetCoordinate_(1,index[1],dim,ghosts,solver->x,x[1]);
    _GetCoordinate_(2,index[2],dim,ghosts,solver->x,x[2]);
    _GetCoordinate_(3,index[3],dim,ghosts,solver->x,x[3]);
    _GetCoordinate_(0,index[0],dim,ghosts,solver->dxinv,dxinv[0]);
    _GetCoordinate_(1,index[1],dim,ghosts,solver->dxinv,dxinv[1]);
    _GetCoordinate_(2,index[2],dim,ghosts,solver->dxinv,dxinv[2]);
    _GetCoordinate_(3,index[3],dim,ghosts,solver->dxinv,dxinv[3]);

    FPPowerSystem3BusDriftFunction(0,params,x,t,drift);

    double local_cfl[ndims];
    local_cfl[0] = absolute(drift[0]) * dt * dxinv[0];
    local_cfl[1] = absolute(drift[1]) * dt * dxinv[1];
    local_cfl[2] = absolute(drift[2]) * dt * dxinv[2];
    local_cfl[3] = absolute(drift[3]) * dt * dxinv[3];

    if (local_cfl[0] > max_cfl) max_cfl = local_cfl[0];
    if (local_cfl[1] > max_cfl) max_cfl = local_cfl[1];
    if (local_cfl[2] > max_cfl) max_cfl = local_cfl[2];
    if (local_cfl[3] > max_cfl) max_cfl = local_cfl[3];

    _ArrayIncrementIndex_(ndims,dim,index,done);
  }

  return(max_cfl);
}