/*
 * Real-Time Workshop code generation for Simulink model "weather.mdl".
 *
 * Model Version                        : 1.4
 * Real-Time Workshop file version      : 5.0 $Date: 2002/05/30 19:21:33 $
 * Real-Time Workshop file generated on : Mon Jan 29 12:34:09 2007
 * TLC version                          : 5.0 (Jun 18 2002)
 * C source code generated on           : Mon Jan 29 12:34:09 2007
 */

#include <math.h>
#include <string.h>
#include "weather.h"
#include "weather_private.h"

/* Block signals (auto storage) */
BlockIO rtB;

/* Block states (auto storage) */
D_Work rtDWork;

/* Parent Simstruct */
static rtModel_weather model_S;
rtModel_weather *const rtM_weather = &model_S;

/* Output and update for action system:   
 *   '<S20>/If Action Subsystem'
 *   '<S20>/If Action Subsystem1'
 *   '<S21>/If Action Subsystem'
 *   '<S21>/If Action Subsystem1'
 *   '<S22>/If Action Subsystem'
 *   '<S22>/If Action Subsystem1'
 *   '<S35>/If Action Subsystem'
 *   '<S35>/If Action Subsystem1'
 *   '<S36>/If Action Subsystem'
 *   '<S36>/If Action Subsystem1'
 *   ...
 */
void weather_If_Action_Subsy_a(real_T *fy0, rtP_weather_If_Action_Subsy_a
 *localP)
{

  /* Constant: '<S23>/0' */
  *fy0 = localP->id_Value;
}

/* Output and update for action system:   
 *   '<S20>/If Action Subsystem3'
 *   '<S21>/If Action Subsystem3'
 *   '<S22>/If Action Subsystem3'
 *   '<S35>/If Action Subsystem3'
 *   '<S36>/If Action Subsystem3'
 *   '<S37>/If Action Subsystem3'
 *   '<S50>/If Action Subsystem3'
 *   '<S51>/If Action Subsystem3'
 *   '<S52>/If Action Subsystem3'
 */
void weather_If_Action_Subsy_b(real_T x, real_T *fy0,
 rtB_weather_If_Action_Subsy_b *localB, rtP_weather_If_Action_Subsy_b *localP)
{

  /* Sum: '<S26>/Sum1' incorporates:
   *   Constant: '<S26>/a'
   *   Constant: '<S26>/b'
   */
  localB->b_a = - localP->a_Value + localP->b_Value;

  /* Product: '<S26>/Product ab (trimf)' incorporates:
   *   Sum: '<S26>/Sum'
   *   Constant: '<S26>/a'
   */
  *fy0 = (x - localP->a_Value) / localB->b_a;
}

/* Output and update for action system:   
 *   '<S20>/If Action Subsystem2'
 *   '<S21>/If Action Subsystem2'
 *   '<S22>/If Action Subsystem2'
 *   '<S35>/If Action Subsystem2'
 *   '<S36>/If Action Subsystem2'
 *   '<S37>/If Action Subsystem2'
 *   '<S50>/If Action Subsystem2'
 *   '<S51>/If Action Subsystem2'
 *   '<S52>/If Action Subsystem2'
 */
void weather_If_Action_Subsy_c(real_T x, real_T *fy0,
 rtB_weather_If_Action_Subsy_c *localB, rtP_weather_If_Action_Subsy_c *localP)
{

  /* Sum: '<S25>/Sum2' incorporates:
   *   Constant: '<S25>/b'
   *   Constant: '<S25>/c'
   */
  localB->c_b = - localP->b_Value + localP->c_Value;

  /* Product: '<S25>/Product cd (trimf)' incorporates:
   *   Sum: '<S25>/Sum3'
   *   Constant: '<S25>/c'
   */
  *fy0 = 1.0 / localB->c_b * (localP->c_Value - x);
}

/* Start for root system: '<Root>' */
void MdlStart(void)
{

  /* FromWorkspace Block: <Root>/From Workspace */
  {

    static real_T pTimeValues[] = { 0.0 };

    static real_T pDataValues[] = { 50.0 };

    rtDWork.From_Workspace_PWORK.TimePtr = (void *) pTimeValues;
    rtDWork.From_Workspace_PWORK.DataPtr = (void *) pDataValues;

    rtDWork.From_Workspace_IWORK.PrevIndex = 0;
  }

  /* If Block: <S22>/If */
  rtDWork.If_a_ActiveSubsystem = -1;

  /* FromWorkspace Block: <Root>/From Workspace1 */
  {

    static real_T pTimeValues[] = { 0.0 };

    static real_T pDataValues[] = { 20.0 };

    rtDWork.From_Workspace1_PWORK.TimePtr = (void *) pTimeValues;
    rtDWork.From_Workspace1_PWORK.DataPtr = (void *) pDataValues;

    rtDWork.From_Workspace1_IWORK.PrevIndex = 0;
  }

  /* If Block: <S50>/If */
  rtDWork.If_b_ActiveSubsystem = -1;

  /* FromWorkspace Block: <Root>/From Workspace2 */
  {

    static real_T pTimeValues[] = { 0.0 };

    static real_T pDataValues[] = { 0.6 };

    rtDWork.From_Workspace2_PWORK.TimePtr = (void *) pTimeValues;
    rtDWork.From_Workspace2_PWORK.DataPtr = (void *) pDataValues;

    rtDWork.From_Workspace2_IWORK.PrevIndex = 0;
  }

  /* If Block: <S36>/If */
  rtDWork.If_c_ActiveSubsystem = -1;

  /* If Block: <S52>/If */
  rtDWork.If_d_ActiveSubsystem = -1;

  /* If Block: <S51>/If */
  rtDWork.If_e_ActiveSubsystem = -1;

  /* If Block: <S20>/If */
  rtDWork.If_f_ActiveSubsystem = -1;

  /* If Block: <S37>/If */
  rtDWork.If_g_ActiveSubsystem = -1;

  /* If Block: <S21>/If */
  rtDWork.If_h_ActiveSubsystem = -1;

  /* If Block: <S35>/If */
  rtDWork.If_i_ActiveSubsystem = -1;
}

/* Outputs for root system: '<Root>' */
void MdlOutputs(int_T tid)
{
  /* local block i/o variables */
  real_T rtb_From_Workspace;
  real_T rtb_From_Workspace1;
  real_T rtb_From_Workspace2;
  real_T rtb_Weighting_a;
  real_T rtb_Weighting_b;
  real_T rtb_Weighting_c;
  real_T rtb_Weighting_d;
  real_T rtb_Weighting_e;
  real_T rtb_Weighting_f;
  real_T rtb_Weighting_g;
  real_T rtb_Weighting_h;
  real_T rtb_Weighting_i;
  real_T rtb_Weighting_j;
  real_T rtb_AggMethod1[101];
  real_T rtb_Sum1_a;
  real_T rtb_Zero_Strength_COA_a;
  real_T rtb_Averaging_COA_a;
  real_T rtb_AggMethod2[101];
  real_T rtb_Sum1_b;
  real_T rtb_Zero_Strength_COA_b;
  real_T rtb_Averaging_COA_b;
  real_T rtb_impMethod_a[202];
  real_T rtb_impMethod_b[202];
  real_T rtb_impMethod_c[202];
  real_T rtb_impMethod_d[202];
  real_T rtb_impMethod_e[202];
  real_T rtb_impMethod_f[202];
  real_T rtb_impMethod_g[202];
  real_T rtb_impMethod_h[202];
  real_T rtb_impMethod_i[202];
  real_T rtb_impMethod_j[202];
  real_T rtb_temp51;
  real_T rtb_temp52;

  /* tid is required for a uniform function interface. This system
   * is single rate, and in this case, tid is not accessed. */
  UNUSED_PARAMETER(tid);

  /* FromWorkspace: '<Root>/From Workspace' */
  {
    real_T *pDataValues = (real_T *) rtDWork.From_Workspace_PWORK.DataPtr;
    rtb_From_Workspace = pDataValues[0];
  }

  /* If: '<S22>/If' */
  {
    int8_T rtAction = -1;
    if (rtb_From_Workspace < (-50.0) || rtb_From_Workspace > 50.0) { /* (u1<a) | (u1>c) */
      rtAction = 0;
      weather_If_Action_Subsy_a(&rtB.Merge_a, (rtP_weather_If_Action_Subsy_a *)
       &rtP.If_Action_a);
    } else if (rtb_From_Workspace == 0.0) { /* u1==b */
      rtAction = 1;
      weather_If_Action_Subsy_a(&rtB.Merge_a, (rtP_weather_If_Action_Subsy_a *)
       &rtP.If_Action_b);
    } else if (rtb_From_Workspace < 0.0) { /*  u1 < b */
      rtAction = 2;
      weather_If_Action_Subsy_b(rtb_From_Workspace, &rtB.Merge_a,
       &rtB.If_Action_c, (rtP_weather_If_Action_Subsy_b *) &rtP.If_Action_c);
    } else {
      rtAction = 3;
      weather_If_Action_Subsy_c(rtb_From_Workspace, &rtB.Merge_a,
       &rtB.If_Action_d, (rtP_weather_If_Action_Subsy_c *) &rtP.If_Action_d);
    }
    rtDWork.If_a_ActiveSubsystem = rtAction;
  }

  /* FromWorkspace: '<Root>/From Workspace1' */
  {
    real_T *pDataValues = (real_T *) rtDWork.From_Workspace1_PWORK.DataPtr;
    rtb_From_Workspace1 = pDataValues[0];
  }

  /* If: '<S50>/If' */
  {
    int8_T rtAction = -1;
    if (rtb_From_Workspace1 < 15.0 || rtb_From_Workspace1 > 65.0) { /* (u1<a) | (u1>c) */
      rtAction = 0;
      weather_If_Action_Subsy_a(&rtB.Merge_b, (rtP_weather_If_Action_Subsy_a *)
       &rtP.If_Action_e);
    } else if (rtb_From_Workspace1 == 40.0) { /* u1==b */
      rtAction = 1;
      weather_If_Action_Subsy_a(&rtB.Merge_b, (rtP_weather_If_Action_Subsy_a *)
       &rtP.If_Action_f);
    } else if (rtb_From_Workspace1 < 40.0) { /*  u1 < b */
      rtAction = 2;
      weather_If_Action_Subsy_b(rtb_From_Workspace1, &rtB.Merge_b,
       &rtB.If_Action_g, (rtP_weather_If_Action_Subsy_b *) &rtP.If_Action_g);
    } else {
      rtAction = 3;
      weather_If_Action_Subsy_c(rtb_From_Workspace1, &rtB.Merge_b,
       &rtB.If_Action_h, (rtP_weather_If_Action_Subsy_c *) &rtP.If_Action_h);
    }
    rtDWork.If_b_ActiveSubsystem = rtAction;
  }

  /* FromWorkspace: '<Root>/From Workspace2' */
  {
    real_T *pDataValues = (real_T *) rtDWork.From_Workspace2_PWORK.DataPtr;
    rtb_From_Workspace2 = pDataValues[0];
  }

  /* If: '<S36>/If' */
  {
    int8_T rtAction = -1;
    if (rtb_From_Workspace2 < (-0.4) || rtb_From_Workspace2 > 0.5) { /* (u1<a) | (u1>c) */
      rtAction = 0;
      weather_If_Action_Subsy_a(&rtB.Merge_c, (rtP_weather_If_Action_Subsy_a *)
       &rtP.If_Action_i);
    } else if (rtb_From_Workspace2 == 0.0) { /* u1==b */
      rtAction = 1;
      weather_If_Action_Subsy_a(&rtB.Merge_c, (rtP_weather_If_Action_Subsy_a *)
       &rtP.If_Action_j);
    } else if (rtb_From_Workspace2 < 0.0) { /*  u1 < b */
      rtAction = 2;
      weather_If_Action_Subsy_b(rtb_From_Workspace2, &rtB.Merge_c,
       &rtB.If_Action_k, (rtP_weather_If_Action_Subsy_b *) &rtP.If_Action_k);
    } else {
      rtAction = 3;
      weather_If_Action_Subsy_c(rtb_From_Workspace2, &rtB.Merge_c,
       &rtB.If_Action_l, (rtP_weather_If_Action_Subsy_c *) &rtP.If_Action_l);
    }
    rtDWork.If_c_ActiveSubsystem = rtAction;
  }

  /* MinMax: '<S5>/andorMethod' */
  {
    real_T rtmin = rtB.Merge_a;

    rtmin = rt_MIN(rtB.Merge_b, rtmin);
    rtmin = rt_MIN(rtB.Merge_c, rtmin);
    rtb_temp52 = rtmin;
  }

  /* Product: '<S5>/Weighting' incorporates:
   *   Constant: '<S5>/Weight'
   */
  rtb_Weighting_a = rtP.Weight_a_Value * rtb_temp52;

  /* If: '<S52>/If' */
  {
    int8_T rtAction = -1;
    if (rtb_From_Workspace1 < (-10.0) || rtb_From_Workspace1 > 40.0) { /* (u1<a) | (u1>c) */
      rtAction = 0;
      weather_If_Action_Subsy_a(&rtB.Merge_d, (rtP_weather_If_Action_Subsy_a *)
       &rtP.If_Action_m);
    } else if (rtb_From_Workspace1 == 15.0) { /* u1==b */
      rtAction = 1;
      weather_If_Action_Subsy_a(&rtB.Merge_d, (rtP_weather_If_Action_Subsy_a *)
       &rtP.If_Action_n);
    } else if (rtb_From_Workspace1 < 15.0) { /*  u1 < b */
      rtAction = 2;
      weather_If_Action_Subsy_b(rtb_From_Workspace1, &rtB.Merge_d,
       &rtB.If_Action_o, (rtP_weather_If_Action_Subsy_b *) &rtP.If_Action_o);
    } else {
      rtAction = 3;
      weather_If_Action_Subsy_c(rtb_From_Workspace1, &rtB.Merge_d,
       &rtB.If_Action_p, (rtP_weather_If_Action_Subsy_c *) &rtP.If_Action_p);
    }
    rtDWork.If_d_ActiveSubsystem = rtAction;
  }

  /* MinMax: '<S7>/andorMethod' */
  {
    real_T rtmin = rtB.Merge_a;

    rtmin = rt_MIN(rtB.Merge_d, rtmin);
    rtmin = rt_MIN(rtB.Merge_c, rtmin);
    rtb_temp52 = rtmin;
  }

  /* Product: '<S7>/Weighting' incorporates:
   *   Constant: '<S7>/Weight'
   */
  rtb_Weighting_b = rtP.Weight_b_Value * rtb_temp52;

  /* If: '<S51>/If' */
  {
    int8_T rtAction = -1;
    if (rtb_From_Workspace1 < (-35.0) || rtb_From_Workspace1 > 15.0) { /* (u1<a) | (u1>c) */
      rtAction = 0;
      weather_If_Action_Subsy_a(&rtB.Merge_e, (rtP_weather_If_Action_Subsy_a *)
       &rtP.If_Action_q);
    } else if (rtb_From_Workspace1 == (-10.0) ) { /* u1==b */
      rtAction = 1;
      weather_If_Action_Subsy_a(&rtB.Merge_e, (rtP_weather_If_Action_Subsy_a *)
       &rtP.If_Action_r);
    } else if (rtb_From_Workspace1 < (-10.0) ) { /*  u1 < b */
      rtAction = 2;
      weather_If_Action_Subsy_b(rtb_From_Workspace1, &rtB.Merge_e,
       &rtB.If_Action_s, (rtP_weather_If_Action_Subsy_b *) &rtP.If_Action_s);
    } else {
      rtAction = 3;
      weather_If_Action_Subsy_c(rtb_From_Workspace1, &rtB.Merge_e,
       &rtB.If_Action_t, (rtP_weather_If_Action_Subsy_c *) &rtP.If_Action_t);
    }
    rtDWork.If_e_ActiveSubsystem = rtAction;
  }

  /* MinMax: '<S8>/andorMethod' */
  {
    real_T rtmin = rtB.Merge_a;

    rtmin = rt_MIN(rtB.Merge_e, rtmin);
    rtmin = rt_MIN(rtB.Merge_c, rtmin);
    rtb_temp52 = rtmin;
  }

  /* Product: '<S8>/Weighting' incorporates:
   *   Constant: '<S8>/Weight'
   */
  rtb_Weighting_c = rtP.Weight_c_Value * rtb_temp52;

  /* If: '<S20>/If' */
  {
    int8_T rtAction = -1;
    if (rtb_From_Workspace < 0.0 || rtb_From_Workspace > 100.0) { /* (u1<a) | (u1>c) */
      rtAction = 0;
      weather_If_Action_Subsy_a(&rtB.Merge_f, (rtP_weather_If_Action_Subsy_a *)
       &rtP.If_Action_u);
    } else if (rtb_From_Workspace == 50.0) { /* u1==b */
      rtAction = 1;
      weather_If_Action_Subsy_a(&rtB.Merge_f, (rtP_weather_If_Action_Subsy_a *)
       &rtP.If_Action_v);
    } else if (rtb_From_Workspace < 50.0) { /*  u1 < b */
      rtAction = 2;
      weather_If_Action_Subsy_b(rtb_From_Workspace, &rtB.Merge_f,
       &rtB.If_Action_w, (rtP_weather_If_Action_Subsy_b *) &rtP.If_Action_w);
    } else {
      rtAction = 3;
      weather_If_Action_Subsy_c(rtb_From_Workspace, &rtB.Merge_f,
       &rtB.If_Action_x, (rtP_weather_If_Action_Subsy_c *) &rtP.If_Action_x);
    }
    rtDWork.If_f_ActiveSubsystem = rtAction;
  }