API tools faq
paste
Advertisement
phystota

def_input

phystota
Feb 4th, 2025
82
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 16.09 KB | None | 0 0
raw download clone embed print report
  1. void Process_MainInputForNumberOfOctrees()
  2. {
  3. //
  4. ///*  find number of octrees needed */
  5.    if(glo_EFieldSolver==0)
  6.    {
  7.    double length[3];
  8.    double min_length = 1000;
  9.    
  10.    length[0] = glo_max_pos[0] - glo_min_pos[0];
  11.    length[1] = glo_max_pos[1] - glo_min_pos[1];
  12.    length[2] = glo_max_pos[2] - glo_min_pos[2];
  13.    
  14.    if(length[0]<min_length)
  15.    {
  16.      min_length = length[0];
  17.    }
  18.    if(length[1]<min_length)
  19.    {
  20.      min_length = length[1];
  21.    }
  22.    if(length[2]<min_length)
  23.    {
  24.      min_length = length[2];
  25.    }
  26.  
  27. //   cout << "Length : " <<length[0] <<" " << length[1] << " " << length[2] << endl;
  28. //   cout << "min_length " << min_length << endl;
  29.  
  30.    double dbl_num_x_queen = (length[0]/min_length);
  31.    double dbl_num_y_queen = (length[1]/min_length);
  32.    double dbl_num_z_queen = (length[2]/min_length);
  33.    cout << " dbl num z queen " << dbl_num_z_queen << endl;
  34.  
  35.    int num_x_queenCells;
  36.    int num_y_queenCells;
  37.    int num_z_queenCells;
  38.  
  39.  
  40.    if(dbl_num_x_queen==1)
  41.    {
  42.      num_x_queenCells = 1;
  43.    }
  44.    else if(dbl_num_x_queen==2)
  45.    {
  46.      num_x_queenCells = 2;
  47.    }
  48.    else
  49.    {
  50.      if(fmod(length[0]*1.0E+07,(2*min_length*1.0E+07))==0)
  51.      {
  52.        num_x_queenCells = int(dbl_num_x_queen)/2;
  53.      }
  54.      else if(fabs(fmod(length[0]*1.0E+07,min_length*1.0E+07))<1E-17)
  55.      {
  56.        num_x_queenCells = dbl_num_x_queen;
  57.      }
  58.    }
  59.  
  60.    if(dbl_num_y_queen==1)
  61.    {
  62.      num_y_queenCells = 1;
  63.    }
  64.    else if(dbl_num_y_queen==2)
  65.    {
  66.      num_y_queenCells = 2;
  67.    }
  68.    else
  69.    {
  70.      if(fmod(length[1]*1.0E+07,(2*min_length*1.0E+7))==0)
  71.      {
  72.        num_y_queenCells = ceil(dbl_num_y_queen/2);
  73.      }
  74.      else if(fabs(fmod(length[1]*1.0E+07,min_length*1.0E+07))<1E-17)
  75.      {
  76.        num_y_queenCells = dbl_num_y_queen;
  77.      }
  78.    }
  79.  
  80.    if(dbl_num_z_queen==1)
  81.    {
  82.      num_z_queenCells = 1;
  83.    }
  84.    else if(dbl_num_z_queen==2)
  85.    {
  86.      num_z_queenCells = 2;
  87.    }
  88.    else
  89.    {
  90.      if(fmod(length[2]*1.0E+7,(2*min_length)*1.0E+7)==0)
  91.      {
  92.        num_z_queenCells = int(dbl_num_z_queen)/2;
  93.        cout << "first case " << endl;
  94.      }
  95.      else if(fabs(fmod(length[2]*1.0e+07,min_length)*1.0E+7)<1E-17)
  96.      {
  97.        num_z_queenCells = dbl_num_z_queen;
  98.        cout << "second case " << num_z_queenCells << endl;
  99.      }
  100.      else
  101.      {
  102.         cout << "third case " << length[2] <<"  " << min_length  << "  " << fmod(length[2]*1.0E+6,min_length*1.0E+6)<< endl;
  103.         num_z_queenCells = dbl_num_z_queen;
  104.      }
  105.    }
  106.  
  107. //   cout << "num x queen " << dbl_num_x_queen << "  ";
  108. //   cout <<"num_y_queen " << dbl_num_y_queen << "  ";
  109. //   cout <<"num_y_queen " << dbl_num_z_queen << endl;
  110.  
  111.    glo_queen_dx = length[0]/num_x_queenCells;
  112.    glo_queen_dy = length[1]/num_y_queenCells;
  113.    glo_queen_dz = length[2]/num_z_queenCells;
  114.  
  115.    cout <<"glo_queen_dx " << glo_queen_dx << "  ";
  116.    cout <<"glo_queen_dx " << glo_queen_dy << "  ";
  117.    cout <<"glo_queen_dx " << glo_queen_dz << endl;
  118.    
  119.    glo_num_octrees = num_x_queenCells * num_y_queenCells * num_z_queenCells;
  120.    glo_num_x_queenCells = num_x_queenCells;
  121.    glo_num_y_queenCells = num_y_queenCells;
  122.    glo_num_z_queenCells = num_z_queenCells;
  123.  
  124.    cout <<"num_octrees :" <<glo_num_octrees <<endl;
  125.    cout << "num_x_queenCells : " <<glo_num_x_queenCells <<endl;
  126.    cout << "num_y_queenCells : " <<glo_num_y_queenCells <<endl;
  127.    cout << "num_z_queenCells : " <<glo_num_z_queenCells <<endl;
  128.    
  129.  
  130.    cout << glo_MPI_PROC_ID << " num procs : " << glo_num_MPI_PROCS << endl;
  131.    double RootFactorTemp;
  132.    RootFactorTemp = double(glo_num_MPI_PROCS)/double(glo_num_octrees);
  133.    cout << glo_MPI_PROC_ID << " root factor temp: " << RootFactorTemp << endl;
  134.  
  135.    double checkVal = pow(RootFactorTemp,double(1.0)/double(3.0)) - floor(pow(RootFactorTemp,double(1.0)/double(3.0))) ;
  136.    int RootFactor;
  137.    if(checkVal<=0.5)
  138.    {
  139. //      RootFactor = floor(pow(RootFactorTemp,double(1.0)/double(3.0)));
  140.       RootFactor = ceil(pow(RootFactorTemp,double(1.0)/double(3.0)));
  141.    }
  142.    else
  143.    {
  144.       RootFactor = ceil(pow(RootFactorTemp,double(1.0)/double(3.0)));
  145.    }
  146.    
  147.    // Increasing roots by a factor of 2 //
  148.    RootFactor = RootFactor*8;
  149.   cout << glo_MPI_PROC_ID << " root factor : " << RootFactor << endl;
  150.  
  151.    glo_num_x_queenCells = glo_num_x_queenCells * RootFactor;
  152.    glo_num_y_queenCells = glo_num_y_queenCells * RootFactor;
  153.    glo_num_z_queenCells = glo_num_z_queenCells * RootFactor;
  154.    glo_num_octrees = glo_num_x_queenCells*glo_num_y_queenCells*glo_num_z_queenCells;
  155.    
  156.    cout <<" ** num_octrees** :" <<glo_num_octrees <<endl;
  157.    cout << " **num_x_queenCells** : " <<glo_num_x_queenCells <<endl;
  158.    cout << " **num_y_queenCells** : " <<glo_num_y_queenCells <<endl;
  159.    cout << " **num_z_queenCells** : " <<glo_num_z_queenCells <<endl;
  160.  
  161.  
  162.  
  163.    glo_queen_gridpts[0] = glo_num_x_queenCells + 1;
  164.    glo_queen_gridpts[1] = glo_num_y_queenCells + 1;
  165.    glo_queen_gridpts[2] = glo_num_z_queenCells + 1;
  166.  
  167.  
  168.    glo_queen_dx = length[0]/glo_num_x_queenCells;
  169.    glo_queen_dy = length[1]/glo_num_y_queenCells;
  170.    glo_queen_dz = length[2]/glo_num_z_queenCells;
  171.  
  172.  
  173.    /* Determine which root goes to which proc */
  174.    int ceil_value;
  175.    int floor_value;
  176.    int numProcsWithCeilVal ;
  177.    int numProcsWithFloorVal;
  178.    double diff_val;
  179.    if(glo_num_octrees>=glo_num_MPI_PROCS)
  180.    {
  181.    /*1. divide N_roots/N_procs = quotient_val */
  182.    double RootsPerProc = double(glo_num_octrees)/double(glo_num_MPI_PROCS);
  183.  //  cout << glo_MPI_PROC_ID << " roots per proc : " << RootsPerProc << endl;
  184.    /*2. ceil_int = ceil(quotient_val)  && floor_int = floor(quotient_val) */
  185.    ceil_value = ceil(RootsPerProc);
  186.    glo_NumRootsCeil = ceil_value;
  187.    floor_value = floor(RootsPerProc);
  188.    glo_NumRootsFloor = floor_value;
  189.    /*3. diff_val = quotient_val - floor_int */
  190.    diff_val = RootsPerProc - floor_value;
  191.    /*4. num_procs_to_get_ceil_values = diff_val*total_num_procs */
  192.    numProcsWithCeilVal = diff_val*glo_num_MPI_PROCS;
  193.    /*5. remainig procs get floor value */
  194.    numProcsWithFloorVal  = glo_num_MPI_PROCS - numProcsWithCeilVal;
  195.    glo_NumProcsWithCeilNumRoots  = numProcsWithCeilVal;
  196.    glo_NumProcsWithFloorNumRoots = numProcsWithFloorVal;
  197.    /*6. these values are equal to the num_octree_roots that belong to this proc
  198.          and will remain the same throughout the computation  */
  199.    }
  200.    else if(glo_num_octrees<glo_num_MPI_PROCS)
  201.    {
  202.       ceil_value = 1;
  203.       floor_value = 0;
  204.       glo_NumRootsCeil = ceil_value;
  205.       glo_NumRootsFloor = floor_value;
  206.       numProcsWithCeilVal = glo_num_octrees;
  207.       numProcsWithFloorVal = glo_num_MPI_PROCS - glo_num_octrees;
  208.       glo_NumProcsWithCeilNumRoots = numProcsWithCeilVal;
  209.       glo_NumProcsWithFloorNumRoots = numProcsWithFloorVal;
  210.      
  211.    }
  212. //   cout << glo_MPI_PROC_ID << " ceilVal: " << ceil_value  << "  " << glo_NumRootsCeil << "  floow val : " << floor_value << "  " << glo_NumRootsFloor << endl;
  213. //   cout << glo_MPI_PROC_ID << " diff_val :  " << diff_val << endl;
  214. //   cout << glo_MPI_PROC_ID << " numprocswithCeil : " << numProcsWithCeilVal << "  " << glo_NumProcsWithCeilNumRoots;
  215. //   cout << "  numprocs with floor  " << numProcsWithFloorVal << "  " << glo_NumProcsWithFloorNumRoots<< endl;
  216.    
  217.    }
  218.    else if(glo_EFieldSolver==1)
  219.    {
  220.  
  221.    double length[3];
  222.    double min_length = 1000;
  223.    
  224.    length[0] = glo_max_pos[0] - glo_min_pos[0];
  225.    length[1] = glo_max_pos[1] - glo_min_pos[1];
  226.    length[2] = glo_max_pos[2] - glo_min_pos[2];
  227.  
  228.    // for wider domain //
  229.  
  230.    if(length[0]<min_length)
  231.    {
  232.      min_length = length[0];
  233.    }
  234.    if(length[1]<min_length)
  235.    {
  236.      min_length = length[1];
  237.    }
  238.    if(length[2]<min_length)
  239.    {
  240.      min_length = length[2];
  241.    }
  242.  
  243.    bool WiderDomain = 0;
  244.    if( (min_length+1E-6)<length[0])
  245.    {
  246.       WiderDomain = 1;
  247.    }
  248.    if( (min_length+1E-6)<length[1])
  249.    {
  250.       WiderDomain = 1;
  251.    }
  252.    if( (min_length+1E-6)<length[2])
  253.    {
  254.       WiderDomain = 1;
  255.    }
  256.  
  257.    if(WiderDomain==1)
  258.    {
  259.       cout << " ========== Processing Queen cells ========== " << endl ;
  260.       cout << min_length << endl;
  261.       double dbl_num_x_queen = ceil((length[0]/min_length));
  262.       double dbl_num_y_queen = ceil((length[1]/min_length));
  263.       double dbl_num_z_queen = ceil((length[2]/min_length));
  264.  
  265.       cout << " dbl num z queen " << dbl_num_z_queen << endl;
  266.       cout << " dbl num y queen " << dbl_num_y_queen << endl;
  267.       cout << " dbl num x queen " << dbl_num_x_queen << endl;
  268.  
  269.       int num_x_queenCells;
  270.       int num_y_queenCells;
  271.       int num_z_queenCells;
  272.  
  273.       if(dbl_num_x_queen==1)
  274.       {
  275.         num_x_queenCells = 1;
  276.       }
  277.       else if(dbl_num_x_queen==2)
  278.       {
  279.         num_x_queenCells = 2;
  280.       }
  281.       if(dbl_num_y_queen==1)
  282.       {
  283.         num_y_queenCells = 1;
  284.       }
  285.       else if(dbl_num_y_queen==2)
  286.       {
  287.         num_y_queenCells = 2;
  288.       }
  289.       // else if(dbl_num_y_queen==4)
  290.       // {
  291.       //   num_y_queenCells = 4;
  292.       // }
  293.       // else if(dbl_num_y_queen==8)
  294.       // {
  295.       //   num_y_queenCells = 8;
  296.       // }
  297.       // else if(dbl_num_y_queen==16)
  298.       // {
  299.       //   num_y_queenCells = 16;
  300.       // }
  301.       // else if(dbl_num_y_queen==32)
  302.       // {
  303.       //   num_y_queenCells = 32;
  304.       // }
  305.       if(dbl_num_z_queen==1)
  306.       {
  307.         num_z_queenCells = 1;
  308.       }
  309.       else if(dbl_num_z_queen==2)
  310.       {
  311.         num_z_queenCells = 2;
  312.       }
  313.       // else if(dbl_num_z_queen==4)
  314.       // {
  315.       //   num_z_queenCells = 4;
  316.       // }
  317.       // else if(dbl_num_z_queen==8)
  318.       // {
  319.       //   num_z_queenCells = 8;
  320.       // }
  321.       // else if(dbl_num_z_queen==12)
  322.       // {
  323.       //   num_z_queenCells = 12;
  324.       // }
  325.       // else if(dbl_num_z_queen==16)
  326.       // {
  327.       //   num_z_queenCells = 16;
  328.       // }
  329.       // else if(dbl_num_z_queen==32)
  330.       // {
  331.       //   num_z_queenCells = 32;
  332.       // }
  333.       // else if(dbl_num_z_queen==64)
  334.       // {
  335.       //   num_z_queenCells = 64;
  336.       // }
  337.       // else if(dbl_num_z_queen==128)
  338.       // {
  339.       //   num_z_queenCells = 128;
  340.       // }
  341.      
  342.  
  343.  
  344.       cout << " X QUEEN CELLS =  " << num_x_queenCells << " length x =" << length[0] << endl ;
  345.       cout << " Y QUEEN CELLS =  " << num_y_queenCells << " length y =" << length[1] << endl ;
  346.       cout << " Z QUEEN CELLS =  " << num_z_queenCells << " length z =" << length[2] << endl ;  
  347.  
  348.       glo_queen_dx = length[0]/num_x_queenCells;
  349.       glo_queen_dy = length[1]/num_y_queenCells;
  350.       glo_queen_dz = length[2]/num_z_queenCells;
  351.  
  352.       cout <<"glo_queen_dx " << glo_queen_dx << "  ";
  353.       cout <<"glo_queen_dy " << glo_queen_dy << "  ";
  354.       cout <<"glo_queen_dz " << glo_queen_dz << endl;
  355.  
  356.       glo_num_octrees = num_x_queenCells * num_y_queenCells * num_z_queenCells;
  357.      
  358.       glo_num_x_queenCells = num_x_queenCells;
  359.       glo_num_y_queenCells = num_y_queenCells;
  360.       glo_num_z_queenCells = num_z_queenCells;
  361.  
  362.  
  363.       cout <<"num_octrees :" <<glo_num_octrees <<endl;
  364.       cout << "num_x_queenCells : " <<glo_num_x_queenCells <<endl;
  365.       cout << "num_y_queenCells : " <<glo_num_y_queenCells <<endl;
  366.       cout << "num_z_queenCells : " <<glo_num_z_queenCells <<endl;
  367.  
  368.  
  369.       cout << glo_MPI_PROC_ID << " num procs : " << glo_num_MPI_PROCS << endl;
  370.       double RootFactorTemp;
  371.       RootFactorTemp = double(glo_num_MPI_PROCS)/double(glo_num_octrees);
  372.       cout << glo_MPI_PROC_ID << " root factor temp: " << RootFactorTemp << endl;
  373.  
  374.       double checkVal = pow(RootFactorTemp,double(1.0)/double(3.0)) - floor(pow(RootFactorTemp,double(1.0)/double(3.0))) ;
  375.       int RootFactor;
  376.       if(checkVal<=0.5)
  377.       {
  378.      //      RootFactor = floor(pow(RootFactorTemp,double(1.0)/double(3.0)));
  379.          RootFactor = ceil(pow(RootFactorTemp,double(1.0)/double(3.0)));
  380.       }
  381.       else
  382.       {
  383.          RootFactor = ceil(pow(RootFactorTemp,double(1.0)/double(3.0)));
  384.       }
  385.  
  386.       // Increasing roots by a factor of 2 //
  387.  
  388.  
  389.       // RootFactor = RootFactor;
  390.       //  cout << glo_MPI_PROC_ID << " root factor : " << RootFactor << endl;
  391.      
  392.       // glo_num_x_queenCells = glo_num_x_queenCells * RootFactor;
  393.       // glo_num_y_queenCells = glo_num_y_queenCells * RootFactor;
  394.       // glo_num_z_queenCells = glo_num_z_queenCells * RootFactor;
  395.       // glo_num_octrees = glo_num_x_queenCells*glo_num_y_queenCells*glo_num_z_queenCells;
  396.  
  397.       // cout <<" ** num_octrees** :" <<glo_num_octrees <<endl;
  398.       // cout << " **num_x_queenCells** : " <<glo_num_x_queenCells <<endl;
  399.       // cout << " **num_y_queenCells** : " <<glo_num_y_queenCells <<endl;
  400.       // cout << " **num_z_queenCells** : " <<glo_num_z_queenCells <<endl;
  401.  
  402.       // glo_queen_gridpts[0] = glo_num_x_queenCells + 1;
  403.       // glo_queen_gridpts[1] = glo_num_y_queenCells + 1;
  404.       // glo_queen_gridpts[2] = glo_num_z_queenCells + 1;
  405.  
  406.  
  407.       // glo_queen_dx = length[0]/glo_num_x_queenCells;
  408.       // glo_queen_dy = length[1]/glo_num_y_queenCells;
  409.       // glo_queen_dz = length[2]/glo_num_z_queenCells;
  410.    }
  411.    else
  412.    {
  413.      double ExpValue = ceil(log(glo_num_MPI_PROCS)/log(8));
  414.      cout << glo_MPI_PROC_ID << " exp value " << ExpValue << endl;
  415.      int RootFactor = double(pow(8,ExpValue))/double(glo_num_MPI_PROCS) ;
  416.    
  417.  
  418.      // Rootfactor //
  419.      RootFactor = RootFactor * 4 ;
  420.      cout << glo_MPI_PROC_ID << " Rootfactor  " << RootFactor << endl;
  421.        
  422.      glo_num_octrees = glo_num_MPI_PROCS * RootFactor;
  423.      
  424.      glo_num_x_queenCells =  pow(glo_num_octrees,(double(1.0)/double(3.0)));
  425.      glo_num_y_queenCells =  pow(glo_num_octrees,(double(1.0)/double(3.0)));
  426.      glo_num_z_queenCells =  pow(glo_num_octrees,(double(1.0)/double(3.0)));
  427. //     glo_num_octrees = glo_num_x_queenCells*glo_num_y_queenCells*glo_num_z_queenCells;
  428.  
  429.  
  430.      cout <<" ** num_octrees** :" <<glo_num_octrees <<endl;
  431.      cout << " **num_x_queenCells** : " <<glo_num_x_queenCells <<endl;
  432.      cout << " **num_y_queenCells** : " <<glo_num_y_queenCells <<endl;
  433.      cout << " **num_z_queenCells** : " <<glo_num_z_queenCells <<endl;
  434.  
  435.      glo_queen_gridpts[0] = glo_num_x_queenCells + 1;
  436.      glo_queen_gridpts[1] = glo_num_y_queenCells + 1;
  437.      glo_queen_gridpts[2] = glo_num_z_queenCells + 1;
  438.  
  439.      cout << " **num_x_queengrid** : " << glo_queen_gridpts[0] <<endl;
  440.      cout << " **num_y_queengrid** : " << glo_queen_gridpts[1] <<endl;
  441.      cout << " **num_z_queengrid** : " << glo_queen_gridpts[2] <<endl;
  442.  
  443.      glo_queen_dx = length[0]/glo_num_x_queenCells;
  444.      glo_queen_dy = length[1]/glo_num_y_queenCells;
  445.      glo_queen_dz = length[2]/glo_num_z_queenCells;
  446.  
  447.      cout << " **queendx** : " <<glo_queen_dx <<endl;
  448.      cout << " **queendx** : " <<glo_queen_dx <<endl;
  449.      cout << " **queendx** : " <<glo_queen_dx <<endl;
  450.    }
  451.        
  452.        /* Determine which root goes to which proc */
  453.        int ceil_value;
  454.        int floor_value;
  455.        int numProcsWithCeilVal ;
  456.        int numProcsWithFloorVal;
  457.        double diff_val;
  458.        if(glo_num_octrees>=glo_num_MPI_PROCS)
  459.        {
  460.        /*1. divide N_roots/N_procs = quotient_val */
  461.        double RootsPerProc = double(glo_num_octrees)/double(glo_num_MPI_PROCS);
  462.  //      cout << glo_MPI_PROC_ID << " roots per proc : " << RootsPerProc << endl;
  463.        /*2. ceil_int = ceil(quotient_val)  && floor_int = floor(quotient_val) */
  464.        ceil_value = ceil(RootsPerProc);
  465.        glo_NumRootsCeil = ceil_value;
  466.        floor_value = floor(RootsPerProc);
  467.        glo_NumRootsFloor = floor_value;
  468.        /*3. diff_val = quotient_val - floor_int */
  469.        diff_val = RootsPerProc - floor_value;
  470.        /*4. num_procs_to_get_ceil_values = diff_val*total_num_procs */
  471.        numProcsWithCeilVal = diff_val*glo_num_MPI_PROCS;
  472.        /*5. remainig procs get floor value */
  473.        numProcsWithFloorVal  = glo_num_MPI_PROCS - numProcsWithCeilVal;
  474.        glo_NumProcsWithCeilNumRoots  = numProcsWithCeilVal;
  475.        glo_NumProcsWithFloorNumRoots = numProcsWithFloorVal;
  476.        /*6. these values are equal to the num_octree_roots that belong to this proc
  477.              and will remain the same throughout the computation  */
  478.        }
  479.        else
  480.        {
  481.            cout << " PLEASE CHANGE THE NUMBER OF PROCESSORS TO A MULTIPLE OF 8. Thank you! " << endl;
  482.        }
  483.  
  484.    }
  485.  
  486.  
  487. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!