syst_graph.cpp

《无线通信系统仿真——c++使用模型》这本书的源代码

        ErrorStream << "resampling rate in instance '"
                      << ((Sdg_Edge_Descr->at(edge_num))->model_id)->GetInstanceName() 
                      << "' of model '" 
                      << ((Sdg_Edge_Descr->at(edge_num))->model_id)->GetModelName() 
                      << "'\n is inconsistent with input/output sampling intervals" << endl;
        exit(0);
        }
      if( n_sig != (r_edge * n_base))
        { // error
        #ifdef _DEBUG
          *DebugFile << " error in case 15b" << endl;
        #endif
        ErrorStream << "\n\n********* FATAL ERROR ************" << endl;
        ErrorStream << "resampling rate in instance '"
                      << ((Sdg_Edge_Descr->at(edge_num))->model_id)->GetInstanceName() 
                      << "' of model '" 
                      << ((Sdg_Edge_Descr->at(edge_num))->model_id)->GetModelName() 
                      << "'\n is inconsistent with input/output block sizes" << endl;
        ErrorStream << "n_base = " << n_base << endl;
        ErrorStream << "r_edge = " << r_edge << endl;
        ErrorStream << "n_sig = " << n_sig << endl;
        exit(0);
        }
      #ifdef _DEBUG
        *DebugFile << " case 15 - all parameters defined" << endl;
      #endif
      break;
    case 16: //backward, constant interval,  nothing defined
      // no action possible
      #ifdef _DEBUG
        *DebugFile << "  case 16 - no action possible" << endl;
      #endif
      return;
    case 17:  //backward, constant interval, resampling rate is defined
      // constant sampling rate : Tn = Tb
      // compute block size : Nn = ceil(Nb / R)

      t_sig = t_base;
      n_sig = int(ceil(n_base / r_edge));
      #ifdef _DEBUG
        *DebugFile << " case 17:\n"
                  << "   new block size = " << n_sig
                  << endl;
      #endif

      break;
    case 18:   //backward, constant interval, sampling interval defined
      // compute resampling rate : R = Tn / Tb
      //      this is not really constant interval if Tn != Tb
      // compute block size : Nn = ceil(Nb / R)

      r_edge = t_sig/t_base;
      n_sig = int(ceil(n_base/r_edge));
      #ifdef _DEBUG
        *DebugFile << " case 18:\n"
                  << "   new block size = " << n_sig
                  << "   new resamp rate = " << r_edge
                  << endl;
      #endif
      break;
    case 19:   //backward, constant interval, resampling rate and 
              //sampling interval are defined
      // compute block size : Nn = ceil(Nb / R)

      n_sig = int(ceil(n_base / r_edge));
      #ifdef _DEBUG
        *DebugFile << " case 19:\n"
                  << "   new block size = " << n_sig
                  << endl;
      #endif
      break;
    case 20:   //backward, constant interval, block size is defined
      // compute resampling rate : R = Nb / Nn
      // constant sampling interval : Tn = Tb

      r_edge = float(n_base) / n_sig;
      t_sig = t_base;
      #ifdef _DEBUG
        *DebugFile << " case 20:\n"
                  << "   new samp interval = " << t_sig
                  << "   new resamp rate = " << r_edge
                  << endl;
      #endif
      break;
    case 21:   //backward, constant interval, resampling rate and block size defined
      // constant sampling interval : Tn = Tb

      t_sig = t_base;
      #ifdef _DEBUG
        *DebugFile << " case 21:\n"
                  << "   new samp interval = " << t_sig
                  << endl;
      #endif
      break;
    case 22:   //backward, constant interval, sampling interval and block size defined
      // compute resampling rate : R = Nb / Nn

      r_edge = n_base / n_sig;
      #ifdef _DEBUG
        *DebugFile << " case 22:\n"
                  << "   new resamp rate = " << r_edge
                  << endl;
      #endif
      break;
    case 23:   //backward, constant interval, all parameters are defined
      #ifdef _DEBUG
        *DebugFile << " case 23 - all parameters defined" << endl;
      #endif
      break;
    case 24:   //forward, constant interval, nothing defined
      // no action possible
      #ifdef _DEBUG
        *DebugFile << " case 24 - no action possible" << endl;
      #endif
      return;
    case 25:   //forward, constant interval, resampling rate is defined
      // constant sampling interval : Tn = Tb
      // compute block size : Nn = ceil(R * Nb)

      t_sig = t_base;
      n_sig = int(ceil(r_edge * n_base));
      #ifdef _DEBUG
        *DebugFile << " case 25:\n"
                  << "   new samp interval = " << t_sig
                  << "   new block size = " << n_sig
                  << endl;
      #endif
      break;
    case 26:    //forward, constant interval, sampling interval defined
      // compute resampling rate : R = Tb / Tn
      // compute block size : Nn = ceil(R * Nb)

      r_edge = t_base / t_sig;
      n_sig = int(ceil(r_edge * n_base));
      #ifdef _DEBUG
        *DebugFile << " case 26:\n"
                  << "   new block size = " << n_sig
                  << "   new resamp rate = " << r_edge
                  << endl;
      #endif
      break;
    case 27:    //forward, constant interval, resampling rate and
                // sampling interval defined
      // compute block size : Nn = ceil(R * Nb)

      n_sig = int(ceil(r_edge * n_base));
      #ifdef _DEBUG
        *DebugFile << " case 27:\n"
                  << "   new block size = " << n_sig
                  << endl;
      #endif
      break;
    case 28:    //forward, constant interval, block size is defined
      // compute resampling rate : R = Nn / Nb
      // constant sampling interval : Tn = Tb

      r_edge = n_sig / n_base;
      t_sig = t_base;
      #ifdef _DEBUG
        *DebugFile << " case 28:\n"
                  << "   new samp interval = " << t_sig
                  << "   new resamp rate = " << r_edge
                  << endl;
      #endif
      break;
    case 29:    //forward, constant interval, resampling rate and
                // block size are defined
      // constant sampling interval : Tn = Tb
      // check block size : (Nn == R * Nb)?

      t_sig = t_base;
      #ifdef _DEBUG
        *DebugFile << " case 29:\n"
                  << "   new samp interval = " << t_sig
                  << endl;
      #endif
      break;
    case 30:    //forward, constant interval, sampling interval and
                // block size are defined
      // compute resampling rate : R = Nn / Nb

      r_edge = n_sig / n_base;
      #ifdef _DEBUG
        *DebugFile << " case 30:\n"
                  << "   new resamp rate = " << r_edge
                  << endl;
      #endif
      break;
    case 31:    //forward, constant interval, all parameters are defined

      #ifdef _DEBUG
        *DebugFile << " case 31 - all parameters defined" << endl;
      #endif
      break;
    default:
      *DebugFile << "Fatal Error in Propagate()" << endl;
      exit(0);
      
    } // end of switch on config_key
      // check for integer block size

//  if( (int(r_edge * n_sig)) != n_base )
//    { // errror
//    *DebugFile << "base block size = " << n_base << endl;
//    *DebugFile << "resampling rate = " << r_edge << endl;
//    *DebugFile << "calculated block size = " << (float(n_base)/r_edge) 
//              << endl;
//    }
  (Sdg_Vert_Descr->at(sig_num))->samp_intvl = t_sig;
  (Sdg_Vert_Descr->at(sig_num))->block_size = n_sig;
  (Sdg_Edge_Descr->at(edge_num))->resamp_rate = r_edge;
  return;
}
//====================================================================
//  Set the propagated values of signal parameters within each
//  individual signal object
void SystemGraph::DistributeSignalParms(void)
{
  int sig_num, block_size;
  GenericSignal *sig_id;
  double samp_intvl;
  int num_nodes = Sig_Dep_Graph->GetNumVerts();

  for( sig_num = 0; sig_num < num_nodes; sig_num++)
    {
    if( ((Sdg_Vert_Descr->at(sig_num))->kind_of_signal) != SK_REGULAR_SIGNAL) continue;
      //
      // else
      sig_id = (Sdg_Vert_Descr->at(sig_num))->signal_id;

      block_size = (Sdg_Vert_Descr->at(sig_num))->block_size;
      sig_id->SetBlockSize( block_size );

      //buffer_size = (Sdg_Vert_Descr->at(sig_num))->buffer_size;
      //sig_id->SetBufferSize( buffer_size );

      samp_intvl = (Sdg_Vert_Descr->at(sig_num))->samp_intvl;
      sig_id->SetSampIntvl( samp_intvl );
    }
  return;
}
//====================================================================
void SystemGraph::AllocateStorageBuffers(void)
{
  int sig_num;
  GenericSignal *sig_id;
  int num_nodes = Sig_Dep_Graph->GetNumVerts();

  for(sig_num = 0; sig_num < num_nodes; sig_num++)
    {
    //------------------------------------------------
    // don't consider dummy signals

    if( ((Sdg_Vert_Descr->at(sig_num))->kind_of_signal) != SK_REGULAR_SIGNAL) continue;
      //
      // else
      sig_id = (Sdg_Vert_Descr->at(sig_num))->signal_id;
      sig_id->AllocateSignalBuffer();
    }
}
//============================================================
void SystemGraph::InitializeReadPtrs(void)
{
  GenericSignal* sig_id;
  int num_sigs = Sig_Dep_Graph->GetNumVerts();
  for(int sig_num = 0; sig_num < num_sigs; sig_num++)
    {
    if( ((Sdg_Vert_Descr->at(sig_num))->kind_of_signal) != SK_REGULAR_SIGNAL ) continue;
        //
        // else
        sig_id = (Sdg_Vert_Descr->at(sig_num))->signal_id;
        sig_id->InitializeReadPtrs();
    }
}
//===================================================================
void SystemGraph::InitializeModels(void)
{
  PracSimModel *model_id;
  *DebugFile << "In SystemGraph::InitializeModels()" << endl;
  EnclaveNumber = 0;
  int num_edges = Sig_Dep_Graph->GetNumEdges();
  for( int edge_num = 0; edge_num < num_edges; edge_num ++)
    {
    model_id = (Sdg_Edge_Descr->at(edge_num))->model_id;
    // note: this might pick up models more than once!

    model_id->Initialize();
    *DebugFile << "Initialized model " << model_id->GetModelName() << ":"
               << model_id->GetInstanceName() << endl;
    }
}
//==============================================================================
void SystemGraph::DeleteModels(void)
{
  PracSimModel *model_id;
  *DebugFile << "In SystemGraph::InitializeModels()" << endl;
  int num_edges = Sig_Dep_Graph->GetNumEdges();
  for(int model_num = 0; model_num < Num_Sys_Lev_Models; model_num++)
    {
    model_id = Syst_Lev_Models->at(model_num);

    #ifdef _DEBUG
    *DebugFile << "Deleting model " << model_id->GetModelName() << ":"
               << model_id->GetInstanceName() << endl;
    #endif
    delete model_id;
    }
}
//==============================================================================
void SystemGraph::RunSimulation(void)
{
  int model_num;
  int model_exec_status;

  EnclaveNumber = 0;
  EnclaveOffset[0] = 0;
  for(model_num = 0; model_num < Num_Sys_Lev_Models; model_num++)
    {
    ActiveModel = Syst_Lev_Models->at(model_num);
    #ifdef _DEBUG
      *DebugFile << "ASG launching Execute for " << ActiveModel->GetModelName() 
                  << ":" << ActiveModel->GetInstanceName() << endl;
    #endif
    model_exec_status = ActiveModel->Execute();
    if( model_exec_status == _MES_AOK ) continue;
      // else take action appropriate for returned status code
      switch (model_exec_status)
        {
        case _MES_RESTART:
          *DebugFile << "Restarting at top of Enclave 0" << endl;
          goto signal_update;
        default: //error
          cout << "unrecognized status returned by model execute method" << endl;
          exit(1);
        } // end of switch on model_exec_status
    }
  SigPlot.CollectData();
  //----------------------------------------------------------------------
  // Update signals
signal_update:
  int num_nodes = Sig_Dep_Graph->GetNumVerts();
  GenericSignal *sig_id;

  for( int sig_num = 0; sig_num < num_nodes; sig_num++)
    {
    if( ((Sdg_Vert_Descr->at(sig_num))->kind_of_signal) != SK_REGULAR_SIGNAL) continue;
      //
      // else
      sig_id = (Sdg_Vert_Descr->at(sig_num))->signal_id;
      sig_id->PassUpdate();
    }
}
//=========================================================================
void SystemGraph::RegisterModel(PracSimModel* model)
{
  if(model->GetNestDepth() == 1)
    {
    // add model to system level list
    Syst_Lev_Models->push_back(model);
    Num_Sys_Lev_Models++;
    }
}
//================================================================
void SystemGraph::AllocatePlotPointers(void)
{
  GenericSignal* sig_id;
  int num_sigs = Sig_Dep_Graph->GetNumVerts();
  for(int sig_num = 0; sig_num < num_sigs; sig_num++)
    {
    sig_id = (Sdg_Vert_Descr->at(sig_num))->signal_id;
    sig_id->SetupPlotSignal();
    }
}
//==========================================================
GenericSignal* SystemGraph::GetSignalId( char* sig_name)
{
  GenericSignal *sig_id;
  int num_sigs = Sig_Dep_Graph->GetNumVerts();
  for(int sig_num = 0; sig_num < num_sigs; sig_num++)
    {
    sig_id = (Sdg_Vert_Descr->at(sig_num))->signal_id;
    if( strcmp( sig_name, sig_id->GetName())) continue;
      return(sig_id);      
    }
  return(NULL);
}