path: root/Donjon/data/Reflector_beavrs_DF-NEM_proc/REFL_MPO_RM.c2m

********************************************************************************
*                                                                              *
* Procedure : REFL_MPO_RM.c2m                                                  *
* Purpose   : Perform a reflector equivalence with a response-matrix method    *
*             (Lefebvre-Lebigot or Koebke) and produce a MPO file              *
* Author    : A. Hebert                                                        *
*                                                                              *
* CALL      :                                                                  *
*  MpoRefl := REFL_MPO_RM Geom FVol Param1 Param2 :: <<nameFeed>> <<nameRefl>> *
*              <<Palier>> <<htype>> <<LibType>> <<NuclData>> <<OptSph>>        *
*              <<OptNoal>> <<OptSS>> <<nbZones>>  ;                            *
*                                                                              *
*  Input objects:                                                              *
*    Geom    : macro-geometry LCM object                                       *
*    FVol    : volume fraction LCM object                                      *
*    Param1  : first feeding assembly global parameter LCM object              *
*    Param2  : second feeding assembly global parameter LCM object             *
*    nameFeed: MPO fine group feeding assembly file name                       *
*    nameRefl: MPO coarse group reflector file name                            *
*    Palier  : type of reflector ('BEAVRS','EPR','VVER', etc.)                 *
*    htype   : type of equivalence ('LEFEBFRE-LEB','KOEBKE')                   *
*    LibType : type of cross-section library used for the reflector            *
*    NuclData: name of the cross-section library used for the reflector as     *
*              set in the .access script file                                  *
*    OptSph  : 'SPH'/'NOSP' transform DF into ADF/keep DF                      *
*    OptNoal : 'ALBE'/'NOAL' compute albedo/force right albedo to 0            *
*    OptSS   : 'TONE'/'NOSS' do/don't activate self-shielding of Fe56 and Cr52 *
*    nbZones : number of zones in the reflector                                *
*                                                                              *
*  Output objects:                                                             *
*    MpoRefl : reflector MPO file                                              *
*                                                                              *
********************************************************************************
PARAMETER MpoRefl Geom FVol Param1 Param2 ::
  ::: HDF5_FILE MpoRefl ;
  ::: LINKED_LIST Geom FVol Param1 Param2 ; ;
STRING nameFeed nameRefl Palier htype LibType NuclData OptSph OptNoal OptSS ;
  ::  >>nameFeed<< >>nameRefl<< >>Palier<< >>htype<< >>LibType<< >>NuclData<<
      >>OptSph<< >>OptNoal<< >>OptSS<< ;
INTEGER nbZones ; :: >>nbZones<< ;
PROCEDURE GetMolarMass MetalMix CreaDilut assertS ;
LINKED_LIST
  DONNEES Library LibDilut MACRO LibFuel MolarMasses FeNat CrNat SnNat
  NiNat ZrNat TiNat SiNat BNat AgNat CdNat SNat GdNat Zirc4 Incon
  SS304 M5 KNat InNat AIC Gd2O3 Edition Multicompo TRACK SYSTEM
  FLUX TRKFIL MCompRefl GeomRefl MacrRefl MacrFuel Param MACRO_FUEL_1
  MACRO_FUEL_2 ;
HDF5_FILE MpoFeed  :: FILE <<nameFeed>> ;
MODULE
  GEO: MCR: ASM: FLU: EDI: MPO: DELETE: UTL: HUTL: END: ABORT: MAC: SNT: TONE: GREP:
  MSTR: BREF: NSST: NSSF: ;
INTEGER ilong nbParam ;
STRING paramname1 paramname2 paramname3 ;
REAL paramvalu1 paramvalu2 paramvalu3 ;

! Donnees a fournir a CreaDilut, fonction de dilution, pour chaque zone
REAL dMod TMil fvMod fvZr4 fvInc fvSS304 fvHe ;
INTEGER premierMIX ;
STRING Localisation := "output_0" ;

*---- Parameters    -----------------------------------
ECHO "...FVol LCM object:" ;
UTL: FVol :: DUMP ;
ECHO "...Param1 LCM object:" ;
UTL: Param1 :: DUMP ;
ECHO "...Param2 LCM object:" ;
UTL: Param2 :: DUMP ;
GREP: Param1 :: LENGTH 'PARAMNAME' >>nbParam<< ;
ECHO "number of global parameters in feeding assembly=" nbParam ;
ECHO "MPO fine group feeding assembly=" nameFeed ;
ECHO "MPO coarse group reflector=" nameRefl ;
IF nbParam 3 > THEN
  ECHO "REFL_MPO: number of global parameters in feeding assembly > 3" ;
  ABORT: ;
ENDIF ;

*---- General informations    -------------------------
ECHO "LibType=" LibType "NuclData="  NuclData ;

*--------------------------------------------------------------------
* Boron tabulation in the reflector
*--------------------------------------------------------------------
INTEGER iBoreMax := 5 ;
DONNEES := UTL: ::
    CREA
          C-BORE <<iBoreMax>> =
            0.0     350.0     700.0    1000.0    1400.0  
    ;

*--------------------------------------------------------------------
* Reflector MPO initialization
*--------------------------------------------------------------------
MpoRefl := MPO: ::
  EDIT 10
  COMM 'Radial reflector XS'
  PARA 'C-BORE'      VALU REAL
  PARA 'Method'      VALU CHAR
  PARA 'Palier'      VALU CHAR
  ;

TRACK := SNT: Geom ::
  EDIT 1
  MAXR 100000
  SN 16 SCAT 2 ;

REAL dModBas := 0.753 ; ! Densite du moderateur en entree du coeur
REAL TMilBas := 286.4 ; ! Temp du reflecteur bas (soit Tmod,entree)
EVALUATE TMilBas := TMilBas 273.15 + ; ! Conversion en Kelvin

! Reflector equivalence variables
REAL Keff SNKeff1 SNKeff2 PCM ;
REAL CB ; ! ppm
INTEGER iPalier ;
LINKED_LIST OUT OUT_1 OUT_2 MACR_TRAC MACR_FLUX ;
INTEGER iZone ;

*-------------------------------------------------------
* Procedures: - Retrieve molar masses (GetMolarMasses)
*             - Create Metal Mixes (MetalMix)
*---- 1) Molar Masses ----------------------------------
MolarMasses := GetMolarMass :: <<NuclData>> <<LibType>> ;

*---- 2) Metal Mixes -----------------------------------
FeNat CrNat SnNat NiNat BNat ZrNat TiNat SiNat KNat AgNat CdNat SNat
InNat Zirc4 Incon SS304 M5 AIC GdNat Gd2O3 := MetalMix
MolarMasses :: <<LibType>> ;

*--------------------------------------------------------------------
*-------------------------Compute LibFuel-------------------------
*--------------------------------------------------------------------
HUTL: MpoFeed :: DIR ;

*--------------------------------------------------------------------
* Loop over the 2 cases, in order to have two different spectrum ratios
*--------------------------------------------------------------------
INTEGER IndexCB ;
INTEGER CASE := 1 ;
WHILE CASE 2 <= DO
  IF CASE 1 = THEN
    Param := Param1 ;
  ELSEIF CASE 2 = THEN
    Param := Param2 ;
  ENDIF ;
  IF nbParam 0 = THEN
    LibFuel :=  MCR: MpoFeed :: EDIT 3 MACRO NMIX 1
      MPO MpoFeed output_0 MIX  1 ENDMIX ;

  ELSEIF nbParam 1 = THEN
    GREP: Param :: STEP UP 'PARAMNAME' GETVAL 1 1 * >>paramname1<< ;
    GREP: Param :: GETVAL 'PARAMVALU' 1 >>paramvalu1<< ;
    ECHO "PARAMNAME(" paramname1 ")=" paramvalu1 ;

    LibFuel :=  MCR: MpoFeed :: EDIT 3 MACRO NMIX 1
      MPO MpoFeed output_0 MIX  1 SET <<paramname1>> <<paramvalu1>>
      ENDMIX ;

  ELSEIF nbParam 2 = THEN
    GREP: Param :: STEP UP 'PARAMNAME' GETVAL 1 1 * >>paramname1<< ;
    GREP: Param :: GETVAL 'PARAMVALU' 1 >>paramvalu1<< ;
    GREP: Param :: STEP UP 'PARAMNAME' GETVAL 2 1 * >>paramname2<< ;
    GREP: Param :: GETVAL 'PARAMVALU' 2 >>paramvalu2<< ;
    ECHO "PARAMNAME(" paramname1 ")=" paramvalu1 ;
    ECHO "PARAMNAME(" paramname2 ")=" paramvalu2 ;

    LibFuel :=  MCR: MpoFeed :: EDIT 3 MACRO NMIX 1
      MPO MpoFeed output_0 MIX  1 SET <<paramname1>> <<paramvalu1>> SET <<paramname2>> <<paramvalu2>>
      ENDMIX ;

  ELSEIF nbParam 3 = THEN
    GREP: Param :: STEP UP 'PARAMNAME' GETVAL 1 1 * >>paramname1<< ;
    GREP: Param :: GETVAL 'PARAMVALU' 1 >>paramvalu1<< ;
    GREP: Param :: STEP UP 'PARAMNAME' GETVAL 2 1 * >>paramname2<< ;
    GREP: Param :: GETVAL 'PARAMVALU' 2 >>paramvalu2<< ;
    GREP: Param :: STEP UP 'PARAMNAME' GETVAL 3 1 * >>paramname3<< ;
    GREP: Param :: GETVAL 'PARAMVALU' 3 >>paramvalu3<< ;
    ECHO "PARAMNAME(" paramname1 ")=" paramvalu1 ;
    ECHO "PARAMNAME(" paramname2 ")=" paramvalu2 ;
    ECHO "PARAMNAME(" paramname3 ")=" paramvalu3 ;

    LibFuel :=  MCR: MpoFeed :: EDIT 3 MACRO NMIX 1
      MPO MpoFeed output_0 MIX  1 SET <<paramname1>> <<paramvalu1>> SET <<paramname2>> <<paramvalu2>>
      SET <<paramname3>> <<paramvalu3>> ENDMIX ;

  ELSE
    ECHO "REFL_MPO_RM: invalid value of nbParam=" nbParam ;
  ENDIF ;
  IF CASE 1 = THEN ! Case A
    MACRO_FUEL_1 := LibFuel ;
  ELSEIF CASE 2 = THEN ! Case B
    MACRO_FUEL_2 := LibFuel ;
  ENDIF ;
  Param LibFuel := DELETE: Param LibFuel ;

  EVALUATE CASE := CASE 1 + ;
ENDWHILE ; ! Loop over CASE

!--------------------------------------------------------------------
! Loop on Boron CB in reflector
!--------------------------------------------------------------------
ECHO "$$$ Branch Boron loop for CASE=" CASE ;
EVALUATE IndexCB := 0 ;
WHILE IndexCB iBoreMax < DO
  EVALUATE IndexCB := IndexCB 1 + ;
  GREP: DONNEES :: GETVAL 'C-BORE' <<IndexCB>> >>CB<< ;
  ECHO "Boron step: " IndexCB "/" iBoreMax " Boron=" CB " ppm    Palier =" Palier ;

  EVALUATE dMod := dModBas ;
  EVALUATE TMil := TMilBas ;
 
  !------------------------------------------------------------
  !  Loop over 2 cases (to get 2 different spectrum ratios)
  !------------------------------------------------------------
  EVALUATE CASE := 1 ;
  WHILE CASE 2 <= DO

    IF CASE 1 = THEN
      MACRO := MACRO_FUEL_1 ;
    ELSEIF CASE 2 = THEN
      MACRO := MACRO_FUEL_2 ;
    ENDIF ;

    EVALUATE iZone := 1 ;
    WHILE iZone nbZones <= DO
      ! Reflector mixtures are defined as .ge. 2
      EVALUATE premierMIX := 1 iZone + ;
      ECHO "First MIX : " premierMIX ;

      ! Recover volumic fractions in the reflector
      GREP: FVol :: LENGTH 'H2O' >>ilong<< ;
      IF ilong 0 > THEN
        GREP: FVol :: GETVAL 'H2O' <<premierMIX>> >>fvMod<< ;
      ELSE
        EVALUATE fvMod := 0.0 ;
      ENDIF ;
      GREP: FVol :: LENGTH 'Zr4' >>ilong<< ;
      IF ilong 0 > THEN
        GREP: FVol :: GETVAL 'Zr4' <<premierMIX>> >>fvZr4<< ;
      ELSE
        EVALUATE fvZr4 := 0.0 ;
      ENDIF ;
      GREP: FVol :: LENGTH 'Inc' >>ilong<< ;
      IF ilong 0 > THEN
        GREP: FVol :: GETVAL 'Inc' <<premierMIX>> >>fvInc<< ;
      ELSE
        EVALUATE fvInc := 0.0 ;
      ENDIF ;
      GREP: FVol :: LENGTH 'SS' >>ilong<< ;
      IF ilong 0 > THEN
        GREP: FVol :: GETVAL 'SS' <<premierMIX>> >>fvSS304<< ;
      ELSE
        EVALUATE fvSS304 := 0.0 ;
      ENDIF ;
      GREP: FVol :: LENGTH 'He' >>ilong<< ;
      IF ilong 0 > THEN
        GREP: FVol :: GETVAL 'He' <<premierMIX>> >>fvHe<< ;
      ELSE
        EVALUATE fvHe := 0.0 ;
      ENDIF ;
      ECHO "[Refl" Localisation
           "] Volume fraction : " iZone ;
      ECHO "- H2O   :      " fvMod " ;" ;
      ECHO "- Zr4   :      " fvZr4 " ;" ;
      ECHO "- Inc   :      " fvInc " ;" ;
      ECHO "- SS304 :      " fvSS304 " ;" ;
      ECHO "- He    :      " fvHe "." ;

      ! Define MIX 1 in reflector macrolib
      LibDilut := CreaDilut
      MolarMasses BNat Zirc4 Incon SS304 ::
        <<dMod>> <<nbZones>> 1 <<TMil>> <<CB>> <<fvMod>> <<fvZr4>> <<fvInc>>
        <<fvSS304>> <<NuclData>> <<LibType>> ;

      ! Recuperation du MIX constitutif de la zone
   
      MACRO := MAC: MACRO LibDilut ::
      NMIX <<premierMIX>> MIX <<premierMIX>> 1 OLDL ;
  
      LibDilut := DELETE: LibDilut ;
      EVALUATE iZone := iZone 1 + ;
    ENDWHILE ;
        
    SYSTEM := ASM: MACRO TRACK :: ARM ;
    FLUX := FLU: SYSTEM MACRO TRACK :: EDIT 0 TYPE K P1 HETE ;

    GREP: FLUX :: GETVAL 'K-EFFECTIVE' 1 >>Keff<< ;
    ECHO "IndexCB=" IndexCB "CASE=" CASE "SN Keff=" Keff ;

    IF nbZones 5 = THEN
      OUT := EDI: MACRO TRACK FLUX Geom ::
          EDIT 3 UPS MERGE MIX 1 2 3 3 4 0
          COND 0.625 GOLVER SAVE ;
    ELSEIF nbZones 6 = THEN
      OUT := EDI: MACRO TRACK FLUX Geom ::
          EDIT 3 UPS MERGE MIX 1 2 3 3 3 4 0
          COND 0.625 GOLVER SAVE ;
    ELSEIF nbZones 7 = THEN
      OUT := EDI: MACRO TRACK FLUX Geom ::
          EDIT 3 UPS MERGE MIX 1 2 3 3 3 3 4 0
          COND 0.625 GOLVER SAVE ;
    ENDIF ;

    IF CASE 1 = THEN
      EVALUATE SNKeff1 := Keff ;
      OUT_1 := OUT ;
    ELSEIF CASE 2 = THEN
      EVALUATE SNKeff2 := Keff ;
      OUT_2 := OUT ;
    ENDIF ;

    SYSTEM FLUX MACRO OUT := DELETE: SYSTEM FLUX MACRO OUT ;

    EVALUATE CASE := CASE 1 + ;
  ENDWHILE ; ! Loop over CASE

  !----------------------------------------------------------
  !  Reflector equivalence procedure
  !----------------------------------------------------------
  ECHO "htype=" htype ;
  ECHO "OptSph=" OptSph ;
  ECHO "OptNoal=" OptNoal ;
  GeomRefl MacrRefl := BREF: Geom OUT_1 OUT_2 ::
     EDIT 2 MIX 0 3 GAP 2 0 HYPE 2 MODEL <<htype>> <<OptSph>> ;
  GeomRefl := GEO: GeomRefl ::
    MIX 1 2
  ;
  ECHO "Macro-geometry used in verification calculation:" ;
  UTL: GeomRefl :: DUMP ;

  !----------------------------------------------------------
  !  Verification calculations
  !----------------------------------------------------------
  MACR_TRAC := NSST: GeomRefl :: EDIT 2 HYPE 2 ;
  EVALUATE CASE := 1 ;
  WHILE CASE 2 <= DO

    ECHO "recover flux CASE=" CASE "IndexCB=" IndexCB ;
    IF CASE 1 = THEN
      MACR_TRAC := NSST: MACR_TRAC GeomRefl :: TITLE "alpha1.txt" ;
      MacrFuel := OUT_1 :: STEP UP 'REF-CASE0001' STEP UP MACROLIB ;
    ELSEIF CASE 2 = THEN
      MACR_TRAC := NSST: MACR_TRAC GeomRefl :: TITLE "alpha2.txt" ;
      MacrFuel := OUT_2 :: STEP UP 'REF-CASE0001' STEP UP MACROLIB ;
    ENDIF ;
    MACRO := MAC: MacrRefl ::
      NMIX 2 MIX 2 1 OLDL ; ! Recover reflector data
    MACRO := MAC: MACRO MacrFuel ::
      MIX 1 1 OLDL ; ! Recover fuel data for specific CASE
        
    MACR_FLUX := NSSF: MACR_TRAC MACRO ::
      EDIT 1
    ;
    GREP: MACR_FLUX :: GETVAL 'K-EFFECTIVE' 1 >>Keff<< ;
    IF CASE 1 = THEN
      EVALUATE PCM := Keff SNKeff1 - 1.E5 * ;
      ECHO "...IndexCB=" IndexCB "CASE=1 SN Keff=" SNKeff1 "macro Keff=" Keff "(" PCM " pcm)" ;
    ELSEIF CASE 2 = THEN
      EVALUATE PCM := Keff SNKeff2 - 1.E5 * ;
      ECHO "...IndexCB=" IndexCB "CASE=2 SN Keff=" SNKeff2 "macro Keff=" Keff "(" PCM " pcm)" ;
    ENDIF ;

    MACRO MacrFuel MACR_FLUX := DELETE: MACRO MacrFuel MACR_FLUX ;

    EVALUATE CASE := CASE 1 + ;
  ENDWHILE ; ! Loop over CASE
  MACR_TRAC OUT_1 OUT_2 := DELETE: MACR_TRAC OUT_1 OUT_2 ;

  !----------------------------------------------------------
  !  MPO reflector creation
  !----------------------------------------------------------
  Edition := EDI: MacrRefl :: EDIT 1 ADFM SAVE ;
  GeomRefl MacrRefl := DELETE: GeomRefl MacrRefl ;

  MpoRefl := MPO: MpoRefl Edition :: EDIT 1
      STEP <<Localisation>>
      C-BORE <<CB>>
      Method <<htype>>
      Palier <<Palier>>
      ;
  Edition := DELETE: Edition ;

ENDWHILE ; ! Loop over IndexCB

END: ;
QUIT "LIST" .