== messy_clamsmix_si.f90 ==

=== sub. clamsmix_global_end ===


 * '''clamsmix_set_config'''
 {{{
SUBROUTINE clamsmix_set_config
 }}}
  * in messy_clamsmix.f90
  * Setze von mix benötigte Variablen:
      adapt_par, time_step, nthetas, l_nthetas, theta_min, theta_max


 * '''clamsmix_set_bounds '''
 {{{
  SUBROUTINE clamsmix_set_bounds 
 }}}
  * in messy_clamsmix.f90 
  * Setze die Grenzen für jedes Level:
      theta_min_act, theta_max_act, theta_delta_act, l_min_act, l_max_act, l_delta_act


 * '''clamsmix_sort'''

 {{{
 SUBROUTINE clamsmix_sort (status, level, indarr, irange)
 }}}

  * Indexsortierung des Levels (ZETA)
  * Variablen
  || status   || integer    ||           || OUT   || Fehlercode ||
  || level    || real(prec) || (dnparts) || IN    || Level (ZETA-Werte)||
  || indarr   || integer    || (dnparts) || OUT   || sortierter Index von levelind||
  || irange   || integer    || (2,l_nthetas,0:ntasks-1) || OUT || Start- und Endposition jedes Levels im sortierten Feld <<BR>> irange(1,i,k): Erster Punkt auf Level i in levelind(indarr) auf PE k <<BR>> irange(2,i,k): Letzter Punkt auf Level i in levelind(indarr) auf PE k||
  || levelind || integer    || (dnparts) || LOKAL || Index der ZETA-Werte in ZETA-Grid||

  * Ermittle zu jedem ZETA-Wert den Index im ZETA-Grid -> levelind
  * Indexsortierung des Feldes levelind -> indarr
  * Ermittle den ersten und letzten Punkt jedes Levels in levelind(indarr) -> irange

  {{{
ipart      1    2    3    4    5    6    7    8    9
 
level     320  330  325  340  322  331  332  342  mdi

levelind   1    2    1    3    1    2    2    3   9999

indarr     1    3    5    2    6    7    4    8    9

levelind   1    1    1    2    2    2    3    3   9999
(indarr)

irange      (1,3)          (4,6)         (7,8)
  }}}




 * '''clamsmix_nparts_per_level '''
 {{{
  SUBROUTINE clamsmix_nparts_per_level (irange, dnparts_level, nparts_level)
  }}}
  * in messy_clamsmix.f90
  * Ermittle die Anzahl Punkte pro Level
  * Parameter:
  || irange        || integer || (2,l_nthetas,0:ntasks-1) || IN  || Start- und Endposition jedes Levels für jede PE||
  || dnparts_level || integer || (l_nthetas,0:ntasks-1)   || OUT || Anzahl Punkte pro Level für jede PE ||
  || nparts_level  || integer || (l_nthetas)              || OUT || Anzahl Punkte pro Level auf allen PEs ||

 * '''clamsmix_set_level ''' 
 {{{
  SUBROUTINE clamsmix_set_level (levelrange, nparts_level)
 }}}
  * in messy_clamsmix.f90
  * Ermittle für jede PE, welche Level bearbeitet werden
  * Wenn mehr CPUs als Level genutzt werden, bearbeiten die ersten nthetas CPUs jeweils ein Level, die weiteren bleiben ungenutzt
  * Bei weniger CPUs als Level wird die Anzahl Punkte möglichst gleichmäßig auf die CPUs verteilt: <<BR>>
  Es wird solange jeweils das nächste Level hinzugefügt, bis die Anzahl der Punkte auf der aktuellen CPU möglichst nah an nparts/ntasks und die Gesamtzahl der bisher zugeteilten Punkte möglichst nah an (nparts/ntasks)*(irank+1) liegt.
  * Parameter:
  || nparts_level || integer || (l_nthetas)   || IN  || Anzahl Punkte pro Level auf allen PEs ||
  || levelrange   || integer || (2,0:ntasks-1)|| OUT || Start- und Endlevel für jede PE ||


 * '''clamsmix_shuffle''' 
 {{{
   SUBROUTINE clamsmix_shuffle (status, my_nparts, indarr, irange, levelrange, &
                        dnparts_level, nparts_level, level, infield, outfield)
 }}}
   * Umsortierung der Punkte:
    Jede PE bekommt alle Punkte, deren Level zwischen levelrange(1,irank) and levelrange(2,irank) liegt
   * Parameter 
   || status       || integer   ||  || OUT || Fehlercode ||
   || my_nparts    || integer   ||  || OUT || neue Anzahl Punkte auf aktueller PE||
   || indarr       || integer   || (dnparts) || IN || ||
   || irange       || integer   || (2,l_nthetas,0:ntasks-1)|| IN || ||
   || levelrange   || integer   || (2,0:ntasks-1) || IN || ||
   || dnparts_level|| integer   || (l_nthetas,0:ntasks-1) || IN || ||
   || nparts_level || integer   || (l_nthetas) || IN || ||
   || level        || real(prec)|| (dnparts_max) || IN || Level (ZETA-Werte) ||
   || infield      || real(prec)|| (dnparts_max) || IN || Umzuordnender Parameter ||
   || outfield     || real(prec)|| (dnparts_max) || OUT || Umgeordneter Parameter ||


  * Jede PE schreibt die Daten, die von ihr selbst bearbeitet werden, zuerst auf outfield
  * Jede PE empfängt von allen anderen die Punkte, die auf den von der PE zu bearbeitenden Leveln liegen, und hängt diese an outfield an
  * Jede PE sendet an alle anderen PEs die Punkte, die auf den von dieser zu bearbeitenden Leveln liegen
  * Falls Unterintervalle für mix gewählt wurden (nintervals>1) müssen noch Punkte aus den Grenzbereichen ausgetauscht werden. Diese werden jeweils auf zwei aufeinanderfolgenden PEs benötigt: <<BR>>
  Von der vorhergehenden PE müssen die Punkte zwischen theta_min_act und l_min_act noch geholt werden. Von der nachfolgenden PE müssen die Punkte zwischen l_max_act und theta_max_act noch geholt werden.
  * setze die aktuelle Anzahl Punkte auf der jeweiligen PE ->my_nparts


 * '''mix'''

 * '''clamsmix_shuffle''' 
 {{{
   SUBROUTINE clamsmix_reshuffle
 }}}

  *Punkte wieder gleichmäßig auf CPUs verteilen