int TransferPressuresToStructures ( fluidagent *  fluidAgent, solidagent *  solidAgent  )

inline

Definition at line 221 of file FsiCoupling.H.

References fluidsInterfaceName, simpalInterfaceName, structuresInterfaceName, surfUtilInterfaceName, and transferAgent.

  { 
    std::stringstream outString;
    int stride = 0, solidStride = 0, solidLoadStride = 0;
    int cap = 0, solidCap = 0, solidLoadCap = 0;
    double *pressures = NULL, *solidPressures = NULL, *solidLoads = NULL;

    //Get pressure array from fluid solver
    COM_get_array((fluidsInterfaceName+".pressure").c_str(),101,&pressures,&stride,&cap);
    int isize = cap*stride;
    //Add atmospheric pressure
    for(int i = 0;i < isize;i++){
      std::cout << "Pressure(" << i << ") = " << pressures[i] << std::endl;
    }
    //Transfer the pressures from the fluid to the solid
    transferAgent->Transfer("pressure","Pressures",true);
    transferAgent->Transfer("pressure","NodePressures",true);

    //Get handles for dataitems needed
    int solidFaceLoadsHandle = COM_get_dataitem_handle(structuresInterfaceName+".FaceLoads");
    if(solidFaceLoadsHandle < 0){
      outString << "Error: (TransferPressuresToStructures)" << std::endl
                << "       No handle for FaceLoads with structure solver" << std::endl;
      StdOut(outString.str(),0,true);
      outString.clear();
      outString.str("");
      return(1);
    }
    int solidPressuresHandle = COM_get_dataitem_handle(structuresInterfaceName+".Pressures");
    if(solidPressuresHandle < 0){
      outString << "Error: (TransferPressuresToStructures)" << std::endl
                << "       No handle for Pressures with structure solver" << std::endl;
      StdOut(outString.str(),0,true);
      outString.clear();
      outString.str("");
      return(1);
    }

    //Account for atmospheric pressure when transferring to Elmer (we aren't doing this)
    //Get pressure array from solid solver
    COM_get_array((structuresInterfaceName+".Pressures").c_str(),11,&solidPressures,
                   &solidStride,&solidCap);
    int solidIsize = solidCap*solidStride;
    //Add atmospheric pressure (we aren't doing this - should we?)
    for(int i = 0;i < solidIsize;i++){
      //solidPressures[i] += 101325.0;
      //solidPressures[i] = 1.0;
      outString << std::setprecision(15) << "solidPressure(" << i << ") = " << solidPressures[i] << std::endl;
    }
    StdOut(outString.str(),3,true);
    outString.clear();
    outString.str("");

    //Get handles for functions needed
    std::string funcName;
    funcName = surfUtilInterfaceName + ".compute_element_normals";
    int faceNormalsHandle = COM_get_function_handle(funcName.c_str());
    if(faceNormalsHandle < 0){
      outString << "Error: (TransferPressuresToStructures)" << std::endl
                << "       No handle for compute_element_normals function " << std::endl;
      StdOut(outString.str(),0,true);
      outString.clear();
      outString.str("");
      return(1);
    }
    funcName = simpalInterfaceName + ".mul";
    int mulHandle = COM_get_function_handle(funcName.c_str());
    if(mulHandle < 0){
      outString << "Error: (TransferPressuresToStructures)" << std::endl
                << "       No handle for simpal multiply function " << std::endl;
      StdOut(outString.str(),0,true);
      outString.clear();
      outString.str("");
      return(1);
    }
    funcName = simpalInterfaceName + ".neg";
    int negHandle = COM_get_function_handle(funcName.c_str());
    if(negHandle < 0){
      outString << "Error: (TransferPressuresToStructures)" << std::endl
                << "       No handle for simpal negate function " << std::endl;
      StdOut(outString.str(),0,true);
      outString.clear();
      outString.str("");
      return(1);
    }

    //Execute the appropriate function calls
    //I'm gonna try not normalizing them!! 
    int normalize=1;
    //Call function to get face normals, store them in solidFaceLoads, do not
    //normalize them
    COM_call_function(faceNormalsHandle, &solidFaceLoadsHandle, &normalize);
    //Call function to get face normals, store them in solidFaceLoads, do not
    //normalize them
    COM_call_function(mulHandle, &solidFaceLoadsHandle, &solidPressuresHandle, 
                      &solidFaceLoadsHandle); 
    COM_call_function(negHandle, &solidFaceLoadsHandle, &solidFaceLoadsHandle); 

    transferagent *structuresTransferAgent   = new transferagent("structuresTransferAgent");
    
    // Initialize the transfer module's common refinement
    structuresTransferAgent->Overlay(structuresInterfaceName,structuresInterfaceName);
 
    // Call the transfer now   
    structuresTransferAgent->Transfer("FaceLoads","Loads");

    //Get loads array from solid solver to check
    COM_get_array((structuresInterfaceName+".Loads").c_str(),11,&solidLoads,
                   &solidLoadStride,&solidLoadCap);
    int solidLoadsize = solidLoadCap*solidLoadStride;
    for(int i = 0;i < solidLoadsize;i++){
      std::cout << std::setprecision(15) << "solidLoads(" << i << ") = " << solidLoads[i] << std::endl;
    }

    //Print out the face normals from the fluid solver as a check
    int fluidFaceNormalsHandle = COM_get_dataitem_handle(fluidsInterfaceName+".normals");
    if(fluidFaceNormalsHandle < 0){
      outString << "Error: (TransferPressuresToStructures)" << std::endl
                << "       No handle for FaceNormals with fluids solver" << std::endl;
      StdOut(outString.str(),0,true);
      outString.clear();
      outString.str("");
      return(1);
    }
    normalize=0;
    COM_call_function(faceNormalsHandle, &fluidFaceNormalsHandle, &normalize);
    double *fluidFaceNormals = NULL;
    COM_get_array((fluidsInterfaceName+".normals").c_str(),101,&fluidFaceNormals,&stride,&cap);
    isize = stride*cap; 

    outString << "stride = " << stride << std::endl;
    std::vector<double> sums (stride, 0.0);
    outString << "Driver: fluid face normals:" << std::endl;
    for(int i=0; i < cap; i++){
      for(int j=0; j < stride; j++){
        outString << fluidFaceNormals[stride*i + j] << " ";
        sums[j] += fluidFaceNormals[stride*i + j];
      }
      outString << std::endl;
    }  
    outString << "sums: ";
    for(int i=0; i < sums.size(); i++)
      outString << sums[i] << " ";
    outString << std::endl;
    StdOut(outString.str(),3,true);
    outString.clear();
    outString.str("");

    return(0); 
  };