dice_check.py

Go to the documentation of this file.

 
 
# Import packages
from DicePy.dice_defaults import *
import f90nml
 
#-----------------------------
# MINOR FUNCTION DEFINITIONS -
#-----------------------------
 
 
def isvalid(tag,value,options):
    if not(value in options):
        print('')
        print('Error: Invalid input \'{:}={:}\'. The program is expecting one of the following inputs:'.format(tag,value))
        print(options)
        print(''); exit()
 
 
def default_message(tag,dval):
    if len(dval)==1:
        print('')
        print('Note: Tag \'{:}\' is not set. Program will use the default \'{:}={:}\'.'.format(tag,tag,dval))
    else:
        print('')
        print('Note: Tag \'{:}\' is not set. Program will use the following default \'{:}\' grid.'.format(tag,tag))
        print(dval)
 
 
def check_step(tag,tags,params,defaults,idx=None):
    if tag in tags:
        val = params[tag]
        if not(type(val) is int):
            print('')
            print('Error: Invalid input \'{:}={:}\': The program is expecting positive integer for tag \'{:}\'.'.format(tag,val,tag))
            print(''); exit()
        else:
            return val
    else:
        if idx==None:
            dval = defaults
        else:
            dval = defaults[idx]
        default_message(tag,dval)
        return dval
 
 
def check_float(tag,tags,params,defaults,idx=None):
    if tag in tags:
        val = params[tag]
        if not(type(val) is float):
            print('')
            print('Error: Invalid input \'{:}={:}\': The program is expecting positive float for tag \'{:}\'.'.format(tag,val,tag))
            print(''); exit()
    else:
        if idx==None:
            dval = defaults
        else:
            dval = defaults[idx]
        default_message(tag,dval)
 
 
def check_grid(tag,tags,params,default_grid):
    if tag in tags:
        length = len(params[tag])
        if length == 3:
            mini, maxi, num = params[tag]
            if not(type(mini) is float):
                print('')
                print('Error: Invalid input \'{:}\' min = {:}: The program is expecting positive float for \'{:}\' grid minimum.'.format(tag,mini,tag))
                print(''); exit()
            elif not(type(maxi) is float):
                print('')
                print('Error: Invalid input \'{:}\' max = {:}: The program is expecting positive float for \'{:}\' grid maximum.'.format(tag,maxi,tag))
                print(''); exit()
            elif mini > maxi:
                print('')
                print('Error: Invalid input: The program requires minimum < maximum for \'{:}\' grid.'.format(tag))
                print(''); exit()
            elif not(type(num) is int):
                print('')
                print('Error: Invalid input \'{:}\' num = {:}: The program is expecting positive integer number of points in \'{:}\' grid.'.format(tag,num,tag))
                print(''); exit()
            elif num <= 0:
                print('')
                print('Error: Invalid input \'{:}\' num = {:}: The program is expecting positive integer number of points in \'{:}\' grid.'.format(tag,num,tag))
                print(''); exit()
            elif mini==maxi and num!=1:
                print('')
                print('Error: Invalid input: For \'{:}\' grid, if minimum=maximum, The program is expecting num=1.'.format(tag))
                print(''); exit()
        else:
            print('')
            print('Error: Invalid input: The program is expecting three input values (minimum, maximum, number of points) for grid \'{:}\'.'.format(tag))
            print(''); exit()
    else:
        default_message(tag,default_grid)
 
 
#------------------------
# MAJOR CHECK FUNCTIONS -
#------------------------
 
 
def check_inputs(nml):
 
    # Check for CONTROL header
    headers = [header for header in nml]
    if not ('control' in headers):
        print('')
        print('Error: Invalid format: CONTROL namelist is missing.')
        print(''); exit()
 
    # Extract tags of CONTROL namelist
    control = nml['control']
    tags = [tag for tag in control]
    ctags = tags.copy()
 
    # Check for invalid tags in CONTROL namelist
    invalid_tags = [tag for tag in ctags if not(tag in corder)]
    if len(invalid_tags)!=0:
        print('')
        print('Error: Invalid tags present in the CONTROL namelist tags.')
        print('Remove the following invalid tags:')
        for tag in invalid_tags:
            print(tag)
        print(''); exit()
 
    # Check order of CONTROL namelist tags
    order = [tag for tag in corder if tag in ctags]
    if not(ctags==order):
        print('')
        print('Error: Invalid format. The CONTROL namelist tags need to be in the following order:')
        print(order)
        print(''); exit()
 
    # Check system
    # Essential tag
    tag = 'p_system'
    if not(tag in tags):
        print('')
        print('Incomplete params.txt: The \'{:}\' tag is missing.'.format(tag))
        print(''); exit()
    p_system = control[tag]
    isvalid(tag,p_system,systems)
 
    # Get system index for defaults
    sys_idx = systems.index(p_system)
 
    # Special Test Case
    if p_system == 'test':
        return
    else:
        # Check for PARAMETERS namelist
        if not ('parameters' in headers):
            print('')
            print('Error: Invalid format: PARAMETERS namelist is missing.')
            print(''); exit()
    
    # Check values in CONTROL namelist
 
    # Check run_equil
    # Default run_equil=.FALSE.
    tag = 'run_equil'
    if tag in tags:
        equi = control[tag]
        isvalid(tag,equi,boolean)
    else:
        default_message(tag,d_equi)
 
    # Check run_restart
    # Default run_restart=.FALSE.
    tag = 'run_restart'
    if tag in tags:
        rres = control[tag]
        isvalid(tag,rres,boolean)
    else:
        default_message(tag,d_rres)
    
    # Check write_restart
    # Default write_restart=.FALSE.
    tag = 'write_restart'
    if tag in tags:
        wres = control[tag]
        isvalid(tag,wres,boolean)
    else:
        wres = d_wres
        default_message(tag,d_wres)
 
    # Check restart_step
    # Default restart_step=1
    if wres:
        tag = 'restart_num'
        if tag in tags:
            rnum = control[tag]
            if not(type(rnum) is int):
                print('')
                print('Error: Invalid input \'{:}={:}\': The program is expecting integer >=0 for tag \'{:}\'.'.format(tag,rnum,tag))
                print(''); exit()
            elif not(rnum>0):
                print('')
                print('Error: Invalid input \'{:}={:}\': The program is expecting a positive integer for tag \'{:}\'.'.format(tag,rnum,tag))
                print(''); exit()
        else:
            default_message(tag,d_rnum)
 
    # Check write_chains
    # Default write_chains=.FALSE. 
    tag = 'write_chains'
    if tag in tags:
        chn = control[tag]
        isvalid(tag,chn,boolean)
        if equi and chn:
            # For equilibration runs, it is redundant to set write_chains=.TRUE.
            print('')
            print('Error: Cannot set write_chain=.TRUE. for equilibration runs.')
            print('       Equilibration runs (run_equil=.TRUE.) automatically output the Markov chains.')
            print('       It is hence redundant to set write_chains=.TRUE. along with run_equil=.TRUE.')
            print('       Please remove the tag "write_chains" from this CONTROL namelist.')
            print(''); exit()
    elif (not equi):
        default_message(tag,d_chn)
 
    # Check write_log
    # Default write_log=.FALSE. 
    tag = 'write_log'
    if tag in tags:
        wlog = control[tag]
        isvalid(tag,wlog,boolean)
    else:
        default_message(tag,d_log)
 
 
    # Check p_system of PARAMETERS namelist
    parameters = nml['parameters']
    sys_small = ['qho','h2plus','h2','test']
    par_sys = [sys for sys in parameters]
    if len(par_sys)==0:
        # Print defaults
        print('')
        print('Note: PARAMETERS namelist is empty.')
        if (equi):
            print('The program will use the following default parameters for equilibration mode.')
            print('steps=',d_equi_steps[sys_idx],', burn_step=0, thin_step=1')
        else:
            print('The program will use the following default parameters for VQMC simulation mode.')
            print('steps=',d_vqmc_steps[sys_idx],', burn_step=',d_bstep[sys_idx],', thin_step=',d_tstep[sys_idx])
        print('rcut=',d_rcut[sys_idx],', sigma=',d_sigma[sys_idx])
        if p_system=='QHO':
            print('alpha=[{:},{:},{:}]'.format(d_alpha[0],d_alpha[1],d_alpha[2]))
        elif p_system=='H2plus':
            print('auto_params=',d_auto_h2plus)
            if d_auto_h2plus=='.TRUE.':
                print('c=',d_c)
            else:
                print('c_grid=[{:},{:},{:}]'.format(d_c_grid[0],d_c_grid[1],d_c_grid[2]))
            print('bond=[{:},{:},{:}]'.format(d_bond_h2plus[0],d_bond_h2plus[1],d_bond_h2plus[2]))
        elif p_system=='H2':
            print('auto_params=',d_auto_h2)
            if d_auto_h2=='.TRUE.':
                print('beta=',d_beta)
            else:
                print('beta_grid=[{:},{:},{:}]'.format(d_beta_grid[0],d_beta_grid[1],d_beta_grid[2]))
            print('bond=[{:},{:},{:}]'.format(d_bond_h2[0],d_bond_h2[1],d_bond_h2[2]))
        return
    elif len(par_sys)>1:
        print('')
        print('Error: Invalid input: Either multiple or no system defitions present in PARAMETERS namelist tags.')
        print('The program is expecting one, and only one, of the following strings before a percent symbol:')
        print(systems)
        print(''); exit()
    elif not (par_sys[0] in sys_small):
        print('')
        print('Error: Invalid system definition in PARAMETERS namelist tags. The program is expecting one of the following strings before a percent symbol:')
        print(systems)
        print(''); exit()
 
    # Extract tags of PARAMETERS namelist
    params = parameters[par_sys[0]]
    tags = [tag for tag in params]
    ptags = tags.copy()
 
    # Check for invalid tags in PARAMMETERS namelist
    if p_system=='QHO':
        porder = porder_qho.copy()
    elif p_system=='H2plus':
        porder = porder_h2plus.copy()
    elif p_system=='H2':
        porder = porder_h2.copy()
    invalid_tags = [tag for tag in ptags if not(tag in porder)]
    if len(invalid_tags)!=0:
        print('')
        print('Error: Invalid tags present in the PARAMETERS namelist tags.')
        print('Remove the following invalid tags:')
        print(invalid_tags)
        print(''); exit()
 
    # Check order of PARAMETERS namelist
    order = [tag for tag in porder if tag in ptags]
    if not(ptags==order):
        print('')
        print('Error: Invalid format. The PARAMETERS namelist tags need to be in the following order:')
        print(order)
        print(''); exit()
    
    # Check values in PARAMETERS namelist
 
    # Check total steps
    steps = check_step('steps',tags,params,d_steps,sys_idx)
 
    # Check burn steps
    bstep = check_step('burn_step',tags,params,d_bstep,sys_idx)
 
    # Check thin steps
    tstep = check_step('thin_step',tags,params,d_tstep,sys_idx)
 
    # Check compatibility of steps
    if bstep >= steps:
        print('')
        print('Error: Incompatable inputs steps={:} and burn_step={:}. The program is expecting burn_step < step.'.format(steps,bstep))
        print(''); exit()
    if tstep >= steps-bstep:
        print('')
        print('Error: Incompatable inputs steps={:}, burn_step={:} and thin_step={:}. The program is expecting thinstep < steps - burn_step.'.format(steps,bstep,tstep))
        print(''); exit()
    if (equi and bstep!=0) or (equi and tstep!=1):
        print('')
        print('Error: Invalid inputs: For equilibration run, the program requires (defaults) burn_step=0 and thin_step=1.')
        print('Either specify these values, or just do not specify these tags so that the program uses the defaults.')
        print(''); exit()
 
    # Check rcut
    check_float('rcut',tags,params,d_rcut,sys_idx)
 
    # Check sigma
    check_float('sigma',tags,params,d_sigma,sys_idx)
 
 
    # System specific parameters
    # QHO
    if p_system=='QHO':
        
        # Check alpha
        check_grid('alpha',tags,params,d_alpha)
 
    # H2plus
    elif p_system=='H2plus':
 
        # Check auto_params
        # Default auto_params=.TRUE.
        tag = 'auto_params'
        if tag in tags:
            auto = control[tag]
            isvalid(tag,auto,boolean)
        else:
            default_message(tag,d_auto_h2plus)
 
        if auto:
            # Check c start guess
            check_float('c',tags,params,d_c)
        else:
            # Check c_grid
            check_grid('c_grid',tags,params,d_c_grid)
        
        # Check bond grid
        check_grid('bond',tags,params,d_bond_h2plus)
 
 
    # H2
    elif p_system=='H2':
 
        # Check auto_params
        # Default auto_params=.TRUE.
        tag = 'auto_params'
        if tag in tags:
            auto = control[tag]
            isvalid(tag,auto,boolean)
        else:
            default_message(tag,d_auto_h2)
        
        if auto:
            # Check beta start guess
            check_float('beta',tags,params,d_beta)
        else:
            # Check beta_grid
            check_grid('beta_grid',tags,params,d_beta_grid)
        
        # Check bond grid
        check_grid('bond',tags,params,d_bond_h2)
 
    # Check for invalid tags in CONTROL namelist
    invalid_tags = [tag for tag in ctags if not(tag in corder)]
    if len(invalid_tags)!=0:
        print('')
        print('Error: Invalid tags present in the CONTROL namelist tags.')
        print('Remove the following invalid tags:')
        print(invalid_tags)
        print(''); exit()
 
    # Check order of CONTROL namelist tags
    order = [tag for tag in corder if tag in ctags]
    if not(ctags==order):
        print('')
        print('Error: Invalid format. The CONTROL namelist tags need to be in the following order:')
        print(order)
        print(''); exit()