#!/usr/bin/perl -w
use strict;
use lib $ENV{ 'MAIN_CONF'}  ;
use main_config ;
my %commands = () ;

if ( @ARGV <= 0 ) { push ( @{$commands{'help'}}, ' ' ) ; } 
else { (%commands) = main_config::get_commands ( @ARGV ) ; }

my $conf_file ;
if ( -f "main_config.data" )
{    $conf_file = "main_config.data" ; }
else
{    $conf_file = join ('', $ENV{"MAIN_CONF"}, "main_config.data" ) ; }

my %my_main = main_config::read_main_config_file ( $conf_file ) ; 

#print " map kicked random: {", @{$my_main{"MAP_KICK_RANDOM"}}, "}\n" ;
#####################################################################

if ( !exists($my_main{"MAP_KIND"} ) )  { push ( @{$my_main{"MAP_KIND"}} , "2FOFC" ) ; }
if ( !exists($my_main{"MAP_OMIT"}  ) )  { push ( @{$my_main{"MAP_OMIT"}} , "OFF" ) ; }
if ( !exists($my_main{"MAP_BULK"}  ) )  { push ( @{$my_main{"MAP_BULK"}} , "ON" ) ; }
if ( !exists($my_main{"MAP_ANISO"}  ) )  { push ( @{$my_main{"MAP_ANISO"}} , "ON" ) ; }
if ( !exists($my_main{"MAP_TARGET"} ) )  { push ( @{$my_main{"MAP_TARGET"}} , "ML" ) ; }
if ( !exists($my_main{"MAP_GENERATION"} ) )  { push ( @{$my_main{"MAP_GENERATION"}} , "FIRST" ) ; }
if ( !exists($my_main{"MAP_WAY"} ) )  { push ( @{$my_main{"MAP_WAY"}} , "SINGLE" ) ; }
if ( !exists($my_main{"MAP_KICK_RANDOM"} ) )  { push ( @{$my_main{"MAP_KICK_RANDOM"}} , "FIXED" ) ; }
if ( !exists($my_main{"MAP_KICK_SIZE"} ) )  { push ( @{$my_main{"MAP_KICK_SIZE"}} , 0.8 ) ; }
if ( !exists($my_main{"MAP_KICK_NN"}  ) )  { push ( @{$my_main{"MAP_KICK_NN"}}  , 30 ) ; }
if ( !exists($my_main{"MAP_PRECISION"}  ) )  { push ( @{$my_main{"MAP_PRECISION"}}  , 7 ) ; }
if ( !exists($my_main{"MAP_NUMBER"}  ) )  { push ( @{$my_main{"MAP_NUMBER"}}  , 1 ) ; }
if ( !exists($my_main{"MAP_BSHARP"}  ) )  { push ( @{$my_main{"MAP_BSHARP"}}  , "OFF" ) ; }
if ( !exists($my_main{"MAP_BSHARP_FACTOR"}  ) )  { push ( @{$my_main{"MAP_BSHARP_FACTOR"}}  , 30. ) ; }
if ( !exists($my_main{"MAP_WRITE"}  ) )  { push ( @{$my_main{"MAP_WRITE"}}  , "OFF" ) ; }

######################################################
#print " map after setup kicked random: {", @{$my_main{"MAP_KICK_RANDOM"}}, "}\n" ;

my $MACRO_FILE = "generate_map.cmds" ;
my $PROC_ERROR = "FALSE" ;
my $doit = "FALSE" ;

my $keyword ; 
foreach $keyword ( sort keys (%commands) ) 
{
#    print "option >$keyword<\n" ; 
    if ( $keyword eq 'h' || substr($keyword, 0,4) eq "help" ) { goto HELP }
    if ( $keyword eq 'm' || substr($keyword, 0,3) eq "map" ) { goto MAP }
    if ( $keyword eq 'o' || substr($keyword, 0,4) eq "omit" ) { goto OMIT }
    if ( $keyword eq 'b' || substr($keyword, 0,4) eq "bulk" ) { goto BULK }
    if ( $keyword eq 'a' || substr($keyword, 0,5) eq "aniso" ) { goto ANISO }

    if ( $keyword eq 't' || substr($keyword, 0,6) eq "target" ) { goto TARGET }
    if ( $keyword eq 'y' || substr($keyword, 0,3) eq "way" ) { goto WAY }
    if ( $keyword eq 'g' || substr($keyword, 0,10) eq "generation" ) { goto GENERATION }
    if ( $keyword eq 'k' || substr($keyword, 0,4) eq "kick" ) { goto KICK }
    if ( $keyword eq 'r' || substr($keyword, 0,6) eq "random" ) { goto RANDOM }
    if ( $keyword eq 'c' || substr($keyword, 0,5) eq "steps" ) { goto STEPS }
    if ( $keyword eq 'n' || substr($keyword, 0,6) eq "number"  ) { goto NUMBER }
    if ( $keyword eq 'f' || substr($keyword, 0,10) eq "sharp_fact" ) { goto SHARP_FACT }
    if ( $keyword eq 's' || substr($keyword, 0,5) eq "sharp" ) { goto SHARP }
    if ( $keyword eq 'p' || substr($keyword, 0,9) eq "precision" ) { goto PRECISION }
    if ( $keyword eq 'w' || substr($keyword, 0,5) eq "write" ) { goto WRITE }

    if ( substr($keyword, 0,4) eq "doit" ) { $doit = "TRUE" ; next ; }
    print "unknown option >$keyword<\n" ; $PROC_ERROR = "TRUE" ;

  HELP:
    print << "END_OF_TEXT" ;
-h|--help)        prints this message with available options and current status 
-m|--map)         map of [2FOFC+FOFC/2FOFC/FOFC/PHASE_COMB/FOBS/FCALC/3FO2FC] [@{$my_main{"MAP_KIND"}}]
-o|--omit)        omit map [ON/OFF] [@{$my_main{"MAP_OMIT"}}]
-b|--bulk)        bulk solvent correction [ON/OFF/USE] [@{$my_main{"MAP_BULK"}}]
-a|--aniso)       anisotropic overall correction [ON/OFF/USE] [@{$my_main{"MAP_ANISO"}}]
-t|--target)      target function [UN/ML] current = [@{$my_main{"MAP_TARGET"}}]
-g|--generation)  map generation [FIRST/SECOND/THIRD] current = [@{$my_main{"MAP_GENERATION"}}]
-y|--way)         map ways [SINGLE/KICK] current = [@{$my_main{"MAP_WAY"}}]
-k|--kick)        maximal xyz kick size [0.0 - 1.33]  current = [@{$my_main{"MAP_KICK_SIZE"}}]
-r|--random)      kick size can be [FIXED/RANDOM/SERIES] = [@{$my_main{"MAP_KICK_RANDOM"}}]
-c|--steps)       kick steps for averaging current = [@{$my_main{"MAP_KICK_NN"}}]
-n|--number)      MAP number [1/2/3/4/5/6/7/8/9/10] [@{$my_main{"MAP_NUMBER"}}]
-s|--sharp)       B-factor sharpening for maps [ON/OFF] [@{$my_main{"MAP_BSHARP"}}]
-f|--sharp_fact)  B-factor sharpening factor [@{$my_main{"MAP_BSHARP_FACTOR"}}]
-p|--precision)   precision of density generation [1/2/3/4/5/6/7/8] [@{$my_main{"MAP_PRECISION"}}]
-w|--write)       write map files [ON/OFF] [@{$my_main{"MAP_WRITE"}}]
   --doit)        create the macro
END_OF_TEXT
    exit ;

  MAP:   @{$my_main{"MAP_KIND"}} = shift ( @{$commands{$keyword}} ) ; next ;
  OMIT:  @{$my_main{"MAP_OMIT"}} = shift ( @{$commands{$keyword}} ) ; next ;
  BULK:  @{$my_main{"MAP_BULK"}} = shift ( @{$commands{$keyword}} ) ; next ;
  ANISO:  @{$my_main{"MAP_ANISO"}} = shift ( @{$commands{$keyword}} ) ; next ;
  TARGET: @{$my_main{"MAP_TARGET"}} = uc(shift ( @{$commands{$keyword}} )) ; next ;
  GENERATION:   @{$my_main{"MAP_GENERATION"}} = shift ( @{$commands{$keyword}} ) ; next ;
  WAY:   @{$my_main{"MAP_WAY"}} = shift ( @{$commands{$keyword}} ) ; next ;
  KICK:  @{$my_main{"MAP_KICK_SIZE"}} = shift ( @{$commands{$keyword}} ) ;  next ;
  RANDOM:  @{$my_main{"MAP_KICK_RANDOM"}} = shift ( @{$commands{$keyword}} ) ;  next ;
  STEPS: @{$my_main{"MAP_KICK_NN"}} = shift ( @{$commands{$keyword}} ) ; next ;
  NUMBER:  @{$my_main{"MAP_NUMBER"}} = shift ( @{$commands{$keyword}} ) ; next ;
  SHARP:   
@{$my_main{"MAP_BSHARP"}} = shift ( @{$commands{$keyword}} ) ;
#print " map sharp:{", @{$my_main{"MAP_BSHARP"}}, "}\n" ;
 next ;
  SHARP_FACT:   
    @{$my_main{"MAP_BSHARP_FACTOR"}} = shift ( @{$commands{$keyword}} ) ; 
#print " fact sharp:{", @{$my_main{"MAP_BSHARP_FACTOR"}}, "}\n" ;
next ;
  PRECISION:  @{$my_main{"MAP_PRECISION"}} = shift ( @{$commands{$keyword}} ) ; next ;
  WRITE:   @{$my_main{"MAP_WRITE"}} = shift ( @{$commands{$keyword}} ) ; next ;
}

if ( $PROC_ERROR eq "TRUE" ) { exit ; }

#######################################

$conf_file = "main_config.data" ; 
main_config::write_main_config_file ( $conf_file, %my_main ) ; 

###  . ${MAIN_CONF}main_config.data.save.sh

if ( $doit eq "FALSE" )  { exit ; }

######################################

    print "SHARP: top flag{",  $my_main{"MAP_BSHARP"}[0], "}\n" ;

my %FILE_WORDS =
    (
     "ROOT" => "./",
     "KICK" => "",
     "KICK_NN" => "",
     "KIND" =>  "_" . $my_main{"MAP_KIND"}[0],
     "TARGET" => "_" . $my_main{"MAP_TARGET"}[0],
     "OMIT" => "",
     "SECOND" => "",
     "EXT" => ".xmap"
    ) ;
    

my $REFL_SELECTION = "WORK_REFL .o TEST .o asymm" ;

if ( $my_main{"MAP_OMIT"}[0] eq "ON" ) { $FILE_WORDS{"OMIT"} = "_omit" ; }
					  
print "creating \"$MACRO_FILE\" \n" ;
if ( -f $MACRO_FILE ) 
{ 
    my $back = join ('', $MACRO_FILE, ".old" ) ; 
    system ( "mv  $MACRO_FILE $back" ) ; 
}
my $THE_MAP ;
open ( MACRO,  "> $MACRO_FILE" ) || die "FILE OPEN ERROR: >$MACRO_FILE< \n" ;

$THE_MAP = ${$my_main{"MAP_NUMBER"}}[0] ;
my $THE_PRECISION = ${$my_main{"MAP_PRECISION"}}[0] ;

print MACRO << "END_OF_TEXT" ;
set vari THE_MAP = $THE_MAP
make map THE_MAP init -9999 auto real cell
make map THE_MAP atom ( precision $THE_PRECISION )
END_OF_TEXT

if ( ${$my_main{"MAP_WAY"}}[0] eq "SINGLE" ) 
{ 

if (${$my_main{"MAP_KIND"}}[0] eq "FOBS" ) 
{

    &create_single_map () ; 

print MACRO << "END_OF_TEXT" ;
refl 
weigh const
set ampl phase fwork = fobs * 1.
exit

END_OF_TEXT


if ( $my_main{"MAP_BSHARP"}[0] eq "ON" )
{
    my $BSHARP = ${$my_main{"MAP_BSHARP_FACTOR"}}[0] ;
    print "SHARP: {", $BSHARP, "}\n" ;
    print MACRO "refl set ampl scale fwork const 1. temp $BSHARP fwork = fwork * 1.0\n" ;
}

print MACRO << "END_OF_TEXT" ;
fill-map THE_MAP select defined end
four map THE_MAP back 
make map THE_MAP rescale 
image map THE_MAP over

END_OF_TEXT

}
else
{
    &create_re_phase () ;
    &create_single_map () ; 
}

#    print " WRITE FIRST MAP {", ${$my_main{"MAP_WRITE"}}[0], "}\n" ; 
    if ( ${$my_main{"MAP_WRITE"}}[0] eq "ON" ) { &write_map () ; }
    if ( ${$my_main{"MAP_GENERATION"}}[0] eq "SECOND" || ${$my_main{"MAP_GENERATION"}}[0] eq "THIRD")
    { 

	print MACRO
#	    "set weight sele segm name WORK_SEGM .a map THE_MAP -1000. 0.8 end = 0\n" ;
	    "set weight sele segm name WORK_SEGM end auto ( dens MAP_CONT map THE_MAP root CA )\n" ;
#	&create_re_phase_next () ;
	&create_re_phase () ;
	&create_single_map () ; 
	$FILE_WORDS{"SECOND"} = "_second" ;

	if ( ${$my_main{"MAP_WRITE"}}[0] eq "ON" ) { &write_map () ; }
    }
    if ( ${$my_main{"MAP_GENERATION"}}[0] eq "THIRD" )
    { 
	print MACRO
	    "set weight sele segm name WORK_SEGM .a map THE_MAP -1000. 0.8 end = 0\n" ;
#	    "set weight sele segm name WORK_SEGM end auto ( dens MAP_CONT map THE_MAP root CA )\n" ;
#	&create_re_phase_next () ;
	&create_re_phase () ;
	&create_single_map () ; 
	$FILE_WORDS{"SECOND"} = "_third" ;
	if ( ${$my_main{"MAP_WRITE"}}[0] eq "ON" ) { &write_map () ; }
    }

    print MACRO "\n return\n" ;

}


#print " map way:  ${$my_main{\"MAP_WAY\"}}[0] \n" ;
if ( ${$my_main{"MAP_WAY"}}[0] eq "KICK" ) 
{ 
    &create_re_phase () ;
    &create_kick_map () ; 
    $FILE_WORDS{"KICK"} = "kick_" . $my_main{"MAP_KICK_SIZE"}[0] ;
    if ( $my_main{"MAP_KICK_RANDOM"}[0] eq "RANDOM" ) 
    { 
	$FILE_WORDS{"KICK"} = "kick_rnd_" . $my_main{"MAP_KICK_SIZE"}[0] ; 
    }
    $FILE_WORDS{"KICK_NN"} = "_" . $my_main{"MAP_KICK_NN"}[0] . "x" ;


    if ( ${$my_main{"MAP_WRITE"}}[0] eq "ON" ) { &write_map () ; }
    if ( ${$my_main{"MAP_GENERATION"}}[0] eq "SECOND" || ${$my_main{"MAP_GENERATION"}}[0] eq "THIRD")
    { 
	print MACRO
	    "set weight sele segm name WORK_SEGM .a map THE_MAP -1000. 0.8 end = 0\n" ;
#	    "set weight sele segm name WORK_SEGM end auto ( dens MAP_CONT map THE_MAP root CA )\n" ;
	&create_re_phase () ;
	&create_kick_map () ; 
	$FILE_WORDS{"SECOND"} = "_second" ;
	if ( ${$my_main{"MAP_WRITE"}}[0] eq "ON" ) { &write_map () ; }
    }
    if ( ${$my_main{"MAP_GENERATION"}}[0] eq "THIRD" )
    { 
	print MACRO
	    "set weight sele segm name WORK_SEGM .a map THE_MAP -1000. 0.8 end = 0\n" ;
#	    "set weight sele segm name WORK_SEGM end auto ( dens MAP_CONT map THE_MAP root CA )\n" ;
	&create_re_phase () ;
	&create_kick_map () ; 
	$FILE_WORDS{"SECOND"} = "_third" ;
	if ( ${$my_main{"MAP_WRITE"}}[0] eq "ON" ) { &write_map () ; }
    }
    print MACRO "\n return\n" ;
}

close ( MACRO ) ;

sub create_single_map
{

print MACRO << "END_OF_TEXT" ;

make map THE_MAP zero
make map THE_MAP conv complex

END_OF_TEXT

if ( ${$my_main{"MAP_KIND"}}[0] eq "3FO2FC" ) 
{
    print " IN MAP 3FO2FC\n" ;
if ( ${$my_main{"MAP_TARGET"}}[0] eq "ML" )
{
print MACRO << "END_OF_TEXT" ;

! echo "SIGMA A 2FO-FC" SIGMAA_MAP RFOBS
refl
sigma_a 2
sele asym .a .not defined end set ampl phase scale fcalc fwork = fcalc * 1. 
exit
END_OF_TEXT
}

if ( ${$my_main{"MAP_TARGET"}}[0] eq "UN" )
{
print MACRO << "END_OF_TEXT" ;
refl 
weigh const
set ampl phase fwork = fcalc * 1.
set ampl scale fcalc     fwork = fobs * 3.0 - fcalc * 2.0
sele asym .a .not defined end set ampl phase scale fcalc fwork = fcalc * 1. 
exit
END_OF_TEXT
}

if ( $my_main{"MAP_BSHARP"}[0] eq "ON" )
{
    my $BSHARP = ${$my_main{"MAP_BSHARP_FACTOR"}}[0] ;
    print MACRO "refl set ampl scale fwork const 1. temp $BSHARP fwork = fwork * 1.0\n" ;
}

print MACRO << "END_OF_TEXT" ;
refl fill-map THE_MAP select $REFL_SELECTION end
four map THE_MAP back 
make map THE_MAP rescale 
image map THE_MAP over
END_OF_TEXT

}


if (${$my_main{"MAP_KIND"}}[0] eq "2FOFC" ) 
{

    print " IN MAP 2FO - FC\n" ;

if ( ${$my_main{"MAP_TARGET"}}[0] eq "ML" )
{
print MACRO << "END_OF_TEXT" ;

! echo "SIGMA A 2FO-FC" SIGMAA_MAP RFOBS
refl
sigma_a 2
sele asym .a .not defined end set ampl phase scale fcalc fwork = fcalc * 1. 
exit
END_OF_TEXT
}

if ( ${$my_main{"MAP_TARGET"}}[0] eq "UN" )
{
print MACRO << "END_OF_TEXT" ;
refl 
weigh const
set ampl phase fwork = fcalc * 1.
set ampl scale fcalc     fwork = fobs * 2.0 - fcalc * 1.0
sele asym .a .not defined end set ampl phase scale fcalc fwork = fcalc * 1. 
exit
END_OF_TEXT
}

if ( $my_main{"MAP_BSHARP"}[0] eq "ON" )
{
    my $BSHARP = ${$my_main{"MAP_BSHARP_FACTOR"}}[0] ;
    print MACRO "refl set ampl scale fwork const 1. temp $BSHARP fwork = fwork * 1.0\n" ;
}

print MACRO << "END_OF_TEXT" ;
refl fill-map THE_MAP select $REFL_SELECTION end
four map THE_MAP back 
make map THE_MAP rescale 
image map THE_MAP over
END_OF_TEXT

}

if (${$my_main{"MAP_KIND"}}[0] eq "FOFC" ) 
{
if ( ${$my_main{"MAP_TARGET"}}[0] eq "ML" )
{
print MACRO << "END_OF_TEXT" ;

! echo "SIGMA A 2FO-FC" SIGMAA_MAP RFOBS
refl
sigma_a 1
exit
END_OF_TEXT
}

if ( ${$my_main{"MAP_TARGET"}}[0] eq "UN" )
{
print MACRO << "END_OF_TEXT" ;
refl 
weigh const
set ampl phase fwork = fcalc * 1.
set ampl scale fcalc     fwork = fobs * 1.0 - fcalc * 1.0
exit
END_OF_TEXT
}

if ( $my_main{"MAP_BSHARP"}[0] eq "ON" )
{
    my $BSHARP = ${$my_main{"MAP_BSHARP_FACTOR"}}[0] ;
    print MACRO "refl set ampl scale fwork const 1. temp $BSHARP fwork = fwork * 1.0\n" ;
}

print MACRO << "END_OF_TEXT" ;

refl fill-map THE_MAP select defined end
four map THE_MAP back 
make map THE_MAP rescale 
image map THE_MAP dens 3.0 map_boxx map_boxx map_boxx
make map THE_MAP + 1 from THE_MAP init 0 real
set vari THE_MAP = THE_MAP + 1
make map THE_MAP conv complex
refl fill-map THE_MAP select defined end
four map THE_MAP back 
make map THE_MAP rescale 
image map THE_MAP dens -3.0 map_boxx map_boxx map_boxx

image map THE_MAP over
END_OF_TEXT

}

if (${$my_main{"MAP_KIND"}}[0] eq "2FOFC+FOFC" ) 
{

    print " IN MAP 2FO - FC\n" ;

if ( ${$my_main{"MAP_TARGET"}}[0] eq "ML" )
{
print MACRO << "END_OF_TEXT" ;

! echo "SIGMA A 2FO-FC" SIGMAA_MAP RFOBS
refl
sigma_a 2
sele asym .a .not defined end set ampl phase scale fcalc fwork = fcalc * 1. 
exit
END_OF_TEXT
}

if ( ${$my_main{"MAP_TARGET"}}[0] eq "UN" )
{
print MACRO << "END_OF_TEXT" ;
refl 
weigh const
set ampl phase fwork = fcalc * 1.
set ampl scale fcalc  fwork = fobs * 2.0 - fcalc * 1.0
sele asym .a .not defined end set ampl phase scale fcalc fwork = fcalc * 1. 
exit
END_OF_TEXT
}

if ( $my_main{"MAP_BSHARP"}[0] eq "ON" )
{
    my $BSHARP = ${$my_main{"MAP_BSHARP_FACTOR"}}[0] ;
    print MACRO "refl set ampl scale fwork const 1. temp $BSHARP fwork = fwork * 1.0\n" ;
}

print MACRO << "END_OF_TEXT" ;
refl fill-map THE_MAP select $REFL_SELECTION end
four map THE_MAP back 
make map THE_MAP rescale 
image map THE_MAP over
END_OF_TEXT

# FO-FC

    print " IN MAP FO - FC\n" ;

print MACRO << "END_OF_TEXT" ;
make map THE_MAP + 1 from THE_MAP init 0 real cell
set vari THE_MAP = THE_MAP + 1
make map THE_MAP conv complex

END_OF_TEXT

if ( ${$my_main{"MAP_TARGET"}}[0] eq "ML" )
{
print MACRO << "END_OF_TEXT" ;

! echo "SIGMA A FO-FC" SIGMAA_MAP RFOBS
refl
sigma_a 1
exit
END_OF_TEXT
}

if ( ${$my_main{"MAP_TARGET"}}[0] eq "UN" )
{
print MACRO << "END_OF_TEXT" ;
refl 
weigh const
set ampl phase fwork = fcalc * 1.
set ampl scale fcalc fwork = fobs * 1.0 - fcalc * 1.0
exit
END_OF_TEXT
}

if ( $my_main{"MAP_BSHARP"}[0] eq "ON" )
{
    my $BSHARP = ${$my_main{"MAP_BSHARP_FACTOR"}}[0] ;
    print MACRO "refl set ampl scale fwork const 1. temp $BSHARP fwork = fwork * 1.0\n" ;
}

print MACRO << "END_OF_TEXT" ;
refl fill-map THE_MAP select defined end
four map THE_MAP back 
make map THE_MAP rescale 
image map THE_MAP over
make map THE_MAP + 1 from THE_MAP init 9999 real copy
image map THE_MAP + 1  over

END_OF_TEXT

}



if (${$my_main{"MAP_KIND"}}[0] eq "FCALC" ) 
{
print MACRO << "END_OF_TEXT" ;
refl 
weigh const
set ampl phase fwork = fcalc * 1.
fill-map THE_MAP select asym end
exit

four map THE_MAP back 
make map THE_MAP rescale 
image map THE_MAP over

END_OF_TEXT

}

if (${$my_main{"MAP_KIND"}}[0] eq "FOBS" ) 
{
print MACRO << "END_OF_TEXT" ;
refl 
weigh const
set ampl phase fwork = fobs * 1.
fill-map THE_MAP select defined end
exit

four map THE_MAP back 
make map THE_MAP rescale 
image map THE_MAP over

END_OF_TEXT

}

}

sub create_re_phase
{

if ( ${$my_main{"MAP_OMIT"}}[0] eq "ON" )
{
print MACRO << "END_OF_TEXT" ;

key map_dens select segm name WORK_SEGM .a .n active end
set vari II integer atom sele map_dens end
if ( II .le. 0 ) then

echo " ------------> %ERROR: YOU CAN NOT OMIT all WORK SEGMENTS - MODIFY key active"
return
end_if


END_OF_TEXT
}
else
{
print MACRO << "END_OF_TEXT" ;
key map_dens select segm name WORK_SEGM end
END_OF_TEXT
}

print MACRO << "END_OF_TEXT" ;

set vari THE_MAP = $THE_MAP

if ( RESOL_MAX .gt. 1.5 ) then
set weight sele segm name WORK_SEGM .a atom name H* end = 0.0
set temp sele segm name WORK_SEGM .a temp -100. 2.0 end = 2.0
end_if

END_OF_TEXT

print MACRO "refl bulk ( least_square )\n" ; 

if ( ${$my_main{"MAP_BULK"}}[0] eq "ON" )
{
print MACRO << "END_OF_TEXT" ;
refl aniso off
make map THE_MAP init -9999 auto real cell

set rad sele segm name WORK_SEGM .a .n segm name XWAT* end  vdw
scale 1.06 rad sele  segm name WORK_SEGM end 

make map THE_MAP bulk \\
     ( select segm name WORK_SEGM end \\
       solvent 0.0 fill 1.8 shrink 0.4 ) 


make map THE_MAP set 9000 99999 1.0
make map THE_MAP set -99990. -9990 0.0

fourier map THE_MAP 
refl bulk off
refl sele defined end set ampl phase fpart = fcalc * 1.0
refl bulk ( on init )

END_OF_TEXT
}
elsif (  ${$my_main{"MAP_BULK"}}[0] eq "USE" )
{
print MACRO << "END_OF_TEXT" ;
refl bulk on

END_OF_TEXT
}
elsif (  ${$my_main{"MAP_BULK"}}[0] eq "OFF" )
{
print MACRO << "END_OF_TEXT" ;
refl bulk off

END_OF_TEXT
}




if ( ${$my_main{"MAP_ANISO"}}[0] eq "ON" )
{
print MACRO << "END_OF_TEXT" ;
refl aniso ( on init )
END_OF_TEXT
}
elsif (  ${$my_main{"MAP_ANISO"}}[0] eq "USE" )
{
print MACRO << "END_OF_TEXT" ;
refl aniso on
END_OF_TEXT
}
elsif (  ${$my_main{"MAP_ANISO"}}[0] eq "OFF" )
{
print MACRO << "END_OF_TEXT" ;
refl aniso off

END_OF_TEXT
}


print MACRO << "END_OF_TEXT" ;

make map THE_MAP conv real
make map THE_MAP zero
 make map THE_MAP set -1 1 -9999.

   make map THE_MAP atom symm -
           atom dens -
           sele map_dens end

 make map THE_MAP set -100000 -100 0.0


fourier map THE_MAP 
END_OF_TEXT

	print MACRO "refl aniso ( init )\n" ; 
#{

if ( ${$my_main{"MAP_OMIT"}}[0] ne "ON" )
{
    if ( ${$my_main{"MAP_BULK"}}[0] eq "ON" )
    {    
	print MACRO "reflection sele WORK_REFL end r-values ( bulk  test TEST ) \n" ;
    }
    
    if ( ${$my_main{"MAP_ANISO"}}[0] eq "ON" )
    {
#	if ( ${$my_main{"MAP_TARGET"}}[0] eq "ML" ) 
#	{ print MACRO "refl aniso ( max_like )\n" ; }
	print MACRO "reflection sele WORK_REFL end r-values ( aniso test TEST )\n" ;
    }
    
    if ( ${$my_main{"MAP_BULK"}}[0] ne "ON" && ${$my_main{"MAP_ANISO"}}[0] ne "ON" )
    { 
	print MACRO "reflection sele WORK_REFL end r-values test TEST\n" ;
    }
}
else
{
    print MACRO "reflection sele WORK_REFL end r-values\n" ;
}


print MACRO << "END_OF_TEXT" ;

 set vari IRESULT_0 global = -1
 refl show key TEST
 show vari IRESULT_0
 if ( IRESULT_0 .gt. 0 ) then
    reflection sele TEST end r-values fix
 end_if
END_OF_TEXT
}

sub create_re_phase_next
{

if ( ${$my_main{"MAP_OMIT"}}[0] eq "ON" )
{
print MACRO << "END_OF_TEXT" ;

key map_dens select segm name WORK_SEGM .a .n active end
set vari II integer atom sele map_dens end
if ( II .le. 0 ) then

echo " ------------> %ERROR: YOU CAN NOT OMIT all WORK SEGMENTS - MODIFY key active"
return
end_if


END_OF_TEXT
}
else
{
print MACRO << "END_OF_TEXT" ;
key map_dens select segm name WORK_SEGM end
END_OF_TEXT
}

print MACRO << "END_OF_TEXT" ;

set vari THE_MAP = $THE_MAP

if ( RESOL_MAX .gt. 1.5 ) then
set weight sele segm name WORK_SEGM .a atom name H* end = 0.0
set temp sele segm name WORK_SEGM .a temp -100. 2.0 end = 2.0
end_if

make map THE_MAP conv real
make map THE_MAP zero

   make map THE_MAP atom symm -
           atom dens -
           sele map_dens end

fourier map THE_MAP 

reflection sele WORK_REFL end r-values

 set vari IRESULT_0 global = -1
 refl show key TEST
 show vari IRESULT_0
 if ( IRESULT_0 .gt. 0 ) then
    reflection sele TEST end r-values fix
 end_if
END_OF_TEXT
}


sub create_kick_map
{

    my $NN_KICK = $my_main{"MAP_KICK_NN"}[0];
    my $KICK = $my_main{"MAP_KICK_SIZE"}[0] ;
    my $KICK_RANDOM = $my_main{"MAP_KICK_RANDOM"}[0] ;
    my $MAP_TARGET = $my_main{"MAP_TARGET"}[0] ;
    my $MAP_KIND = $my_main{"MAP_KIND"}[0] ;
    my $MAP_OMIT = $my_main{"MAP_OMIT"}[0] ;


    my $RFOBS = 999.0 ; my $RFCALC = -999.0 ;
    if ( $MAP_KIND eq "FOFC" ) { $RFOBS = 1.0 ; $RFCALC = 1.0 ; }
    if ( $MAP_KIND eq "2FOFC" ) { $RFOBS = 2.0 ; $RFCALC = 1.0 ; }
    if ( $MAP_KIND eq "3FO2FC" ) { $RFOBS = 3.0 ; $RFCALC = 2.0 ; }

if ( $RFOBS == 999.0 )
{
    print " create_map_calc.pl> EROOR: map kind $MAP_KIND, $RFOBS can not be kicked\n" ;
    exit ;
}
if ( $MAP_TARGET eq "ML" && $MAP_KIND eq "2FOFC" ) 
{
#! echo "SIGMA A 2FO-FC" SIGMAA_MAP RFOBS
    print MACRO << "END_OF_TEXT" ;
refl
sigma_a 2
exit
END_OF_TEXT
}

if ( $MAP_TARGET eq "ML" && $MAP_KIND eq "FOFC" ) 
{
#! echo "SIGMA A 2FO-FC" SIGMAA_MAP RFOBS
    print MACRO << "END_OF_TEXT" ;
refl
sigma_1 1
exit
END_OF_TEXT
}

print MACRO "refl set ampl fstore = 0.\n" ;
#print MACRO "refl aniso off \n" ;
#print MACRO "refl bulk off \n" ;

#make map 1 zero

my $MY_SERIES = 1 ;
my $MY_KICK = $KICK ;
my $NN_SERIES ;
if ( $KICK_RANDOM eq "SERIES" ) { $MY_KICK = 0.0 ; $MY_SERIES = 10}


for ( $NN_SERIES = 1; $NN_SERIES <= $MY_SERIES ; $NN_SERIES++ )
{
    if ( $KICK_RANDOM eq "SERIES" ) { $MY_KICK =  0.1 * $NN_SERIES * $KICK; }
#    print " $NN_SERIES, $MY_SERIES = series: $MY_KICK\n" ;

    my $NN ;
    for ( $NN = 0; $NN < $NN_KICK ; $NN++ )
    {
	if ( $KICK_RANDOM eq "RANDOM" ) { $MY_KICK = rand ( $KICK ) ; }
#	print "! cycle $NN $NN_KICK $MY_KICK\n" ;
	print MACRO "! cycle $NN $NN_KICK \n" ;
	print MACRO << "END_OF_TEXT" ;

make map $THE_MAP conv real
make map $THE_MAP zero 
 make map $THE_MAP set -10 10 -9999.

set coor sele segm name WORK_SEGM end kick $MY_KICK 
END_OF_TEXT

if ( $MAP_OMIT eq "ON" ) 
{
    print MACRO << "END_OF_TEXT" ;
   make map $THE_MAP atom symm -
           atom dens -
           sele segm name WORK_SEGM .a .n active end
END_OF_TEXT
}
else
{
    print MACRO << "END_OF_TEXT" ;
   make map $THE_MAP atom symm -
           atom dens -
           sele segm name WORK_SEGM end
END_OF_TEXT
}

print MACRO << "END_OF_TEXT" ;

<>cmds/un_do.cmds

 make map $THE_MAP set -100000 -100 0.
 fourier map $THE_MAP 
 reflection select WORK_REFL end r-values 
END_OF_TEXT

#!set vari BSHARP = -6 * 3.14 * 3.14 * KICK * KICK

if ( $MAP_TARGET eq "ML" && $MAP_KIND eq "2FOFC" ) 
{
#! echo "SIGMA A 2FO-FC" SIGMAA_MAP RFOBS
    print MACRO << "END_OF_TEXT" ;
refl
sigma_b 2
exit
END_OF_TEXT
}

if ( $MAP_TARGET eq "ML" && $MAP_KIND eq "FOFC" ) 
{
#! echo "SIGMA A 2FO-FC" SIGMAA_MAP RFOBS
    print MACRO << "END_OF_TEXT" ;
refl
sigma_b 1
exit
END_OF_TEXT
}

if ( $MAP_TARGET eq "UN" ) 
{
    print MACRO << "END_OF_TEXT" ;
refl 
weigh const
set ampl phase fwork = fcalc * 1.
sele defined end set ampl scale fcalc   fwork = fobs * $RFOBS - fcalc * $RFCALC

exit
END_OF_TEXT
}

print MACRO "refl set ampl phase fstore = fstore * 1.0 + fwork * 0.1\n" ;

# print MACRO << "END_OF_TEXT" ;
# make map $THE_MAP zero
# make map $THE_MAP conv complex
# refl fill-map $THE_MAP select  WORK_REFL .o TEST end
# four map $THE_MAP back 
# make map $THE_MAP prescale 
# make map 1 from $THE_MAP add
# 
# END_OF_TEXT


    }
}

print MACRO << "END_OF_TEXT" ;
make map $THE_MAP conv complex
make map $THE_MAP zero
refl 
sele defined end set ampl phase fwork = fstore * 1.0
fill-map THE_MAP select $REFL_SELECTION end
exit
END_OF_TEXT


    print "SHARP: in flag{",  $my_main{"MAP_BSHARP"}[0], "}\n" ;
if ( $my_main{"MAP_BSHARP"}[0] eq "ON" )
{
    my $BSHARP = ${$my_main{"MAP_BSHARP_FACTOR"}}[0] ;
    print "SHARP: in long{", $BSHARP, "}\n" ;
    print MACRO "refl set ampl scale fwork const 1. temp $BSHARP fwork = fwork * 1.0\n" ;
}

print MACRO << "END_OF_TEXT" ;
four map $THE_MAP back 
make map $THE_MAP prescale 
image map $THE_MAP over

END_OF_TEXT

}

sub create_series_map
{

}

sub write_map
{
#    my ( $ref_words, $ref_the_map ) = @_ ;
#    my %FILE_WORDS = %{$ref_words} ;

    my $FILE_NAME = join( "", $FILE_WORDS{"ROOT"}, $FILE_WORDS{"KICK"}, $FILE_WORDS{"KICK_NN"}, 
			  $FILE_WORDS{"KIND"}, $FILE_WORDS{"TARGET"}, $FILE_WORDS{"OMIT"}, 
			  $FILE_WORDS{"SECOND"}, $FILE_WORDS{"EXT"}  ) ;
    
    print MACRO "write over file $FILE_NAME map $THE_MAP xpl\n" ; 
}