FPPowerSystem3BusComputeDiffNumber.c File Reference

Function to compute the maximum diffusion number. 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	FPPowerSystem3BusDissipationFunction (int, int, void *, double, double *)
double	FPPowerSystem3BusComputeDiffNumber (void *s, void *m, double dt, double t)

Detailed Description

Function to compute the maximum diffusion number.

Author

Debojyoti Ghosh

Definition in file FPPowerSystem3BusComputeDiffNumber.c.

Function Documentation

FPPowerSystem3BusDissipationFunction()

int FPPowerSystem3BusDissipationFunction	(	int	dir1,
		int	dir2,
		void *	p,
		double	t,
		double *	dissp
	)

Compute the dissipation coefficient for the 3-bus power system

Parameters

dir1	First spatial dimension for the dissipation coefficient
dir2	Second spatial dimension for the dissipation coefficient
p	Object of type FPPowerSystem3Bus
t	Current simulation time
dissp	Matrix of size ndims*ndims to hold the dissipation coefficients (row-major format)

Definition at line 117 of file FPPowerSystem3BusFunctions.c.

{
  FPPowerSystem3Bus *params = (FPPowerSystem3Bus*) p;
  _ArraySetValue_(dissp,_MODEL_NDIMS_*_MODEL_NDIMS_,0.0);

  double sigma11 = params->sigma[0][0];
  double sigma12 = params->sigma[0][1];
  double sigma21 = params->sigma[1][0];
  double sigma22 = params->sigma[1][1];

  double lambda11 = params->lambda[0][0];
  double lambda12 = params->lambda[0][1];
  double lambda21 = params->lambda[1][0];
  double lambda22 = params->lambda[1][1];

  double gamma  = params->gamma;
  double omegaB = params->omegaB;

#if 0
  /* steady state coefficients */
  dissp[2*_MODEL_NDIMS_+0] = sigma11*sigma11*lambda11*lambda11*omegaB;
  dissp[2*_MODEL_NDIMS_+1] = sigma12*sigma12*lambda12*lambda12*omegaB;
  dissp[3*_MODEL_NDIMS_+0] = sigma21*sigma21*lambda21*lambda21*omegaB;
  dissp[3*_MODEL_NDIMS_+1] = sigma22*sigma22*lambda22*lambda22*omegaB;

  dissp[2*_MODEL_NDIMS_+2] = sigma11*sigma11*lambda11*(1.0-gamma*lambda11);
  dissp[2*_MODEL_NDIMS_+3] = sigma12*sigma12*lambda12*(1.0-gamma*lambda12);
  dissp[3*_MODEL_NDIMS_+2] = sigma21*sigma21*lambda21*(1.0-gamma*lambda21);
  dissp[3*_MODEL_NDIMS_+3] = sigma22*sigma22*lambda22*(1.0-gamma*lambda22);
#endif

  /* time-dependent coefficients */
  dissp[2*_MODEL_NDIMS_+0] = sigma11*sigma11*lambda11*omegaB*(lambda11*(1-exp(-t/lambda11))-t*exp(-t/lambda11));
  dissp[2*_MODEL_NDIMS_+1] = sigma12*sigma12*lambda12*omegaB*(lambda12*(1-exp(-t/lambda12))-t*exp(-t/lambda12));
  dissp[3*_MODEL_NDIMS_+0] = sigma21*sigma21*lambda21*omegaB*(lambda21*(1-exp(-t/lambda21))-t*exp(-t/lambda21));
  dissp[3*_MODEL_NDIMS_+1] = sigma22*sigma22*lambda22*omegaB*(lambda22*(1-exp(-t/lambda22))-t*exp(-t/lambda22));

  dissp[2*_MODEL_NDIMS_+2] = sigma11*sigma11*(lambda11*(1-exp(-t/lambda11))+gamma*lambda11*(t*exp(-t/lambda11)-lambda11*(1-exp(-t/lambda11))));
  dissp[2*_MODEL_NDIMS_+3] = sigma12*sigma12*(lambda12*(1-exp(-t/lambda12))+gamma*lambda12*(t*exp(-t/lambda12)-lambda12*(1-exp(-t/lambda12))));
  dissp[3*_MODEL_NDIMS_+2] = sigma21*sigma21*(lambda21*(1-exp(-t/lambda21))+gamma*lambda21*(t*exp(-t/lambda21)-lambda21*(1-exp(-t/lambda21))));
  dissp[3*_MODEL_NDIMS_+3] = sigma22*sigma22*(lambda22*(1-exp(-t/lambda22))+gamma*lambda22*(t*exp(-t/lambda22)-lambda22*(1-exp(-t/lambda22))));

  return(0);
}

FPPowerSystem3BusComputeDiffNumber()

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

Computes the maximum diffusion number over the domain. Note that the diffusion 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 FPPowerSystem3BusComputeDiffNumber.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_diff = 0;
  int     index[ndims];
  int done = 0; _ArraySetValue_(index,ndims,0);
  while (!done) {
    double dxinv[ndims],dissp[ndims*ndims];
    _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]);
    FPPowerSystem3BusDissipationFunction(0,0,params,t,dissp);

    double local_diff[ndims];
    local_diff[0] = absolute(dissp[0*ndims+0]) * dt * dxinv[0] * dxinv[0];
    local_diff[1] = absolute(dissp[1*ndims+1]) * dt * dxinv[1] * dxinv[1];
    local_diff[2] = absolute(dissp[2*ndims+2]) * dt * dxinv[2] * dxinv[2];
    local_diff[3] = absolute(dissp[3*ndims+3]) * dt * dxinv[3] * dxinv[3];

    if (local_diff[0] > max_diff) max_diff = local_diff[0];
    if (local_diff[1] > max_diff) max_diff = local_diff[1];
    if (local_diff[2] > max_diff) max_diff = local_diff[2];
    if (local_diff[3] > max_diff) max_diff = local_diff[3];

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

  return(max_diff);
}