XRS_swissknife.py

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import scipy
import json
### __doc__="""


generality_doc = 1
"""
Documentation of XRS_swissknife
-------------------------------

The script is called in this way ::

  XRS_swissknife yourinput.yaml

The input file is in *yaml* format. In *yaml* format each line introduces an item
and the indentation expresses the hierarchy.
An example is ::

  Fancy_Reduction :
        parameterTom : 3.14
        parameterJerry : False
        choicesBob     : [1,2,3]

In this example we create an item called *Fancy_Reduction* which contains three subitems.

The *XRS_swissknife* expects that for each operation that you want to apply, you provide an item
named as the operation, and the associated subitems that provide that values for the parameters.

*XRS_swissknife* will do what you want provided you respect the proper indentation. A thing which helps
is using emacs and activating the *python mode*, because python uses the same indentation principle
to structure the code. 

Each processing item has the additional, optional, key **active**.
This key can be set to **0** or **1** to desactivate or not (default is **1**, active) the processing.
Here a desactivation example ::

  Fancy_Reduction :
        active : 0
        parameterTom : 3.14
        parameterJerry : False
        choicesBob     : [1,2,3]

The following documentation has been created automatically, for each functionality, based on the documentation string
written in the code for the fonctionality itself.  You can also write mathematical expressions :  :math:`\\int{ x dx} = \\frac { x^2 }{ 2 }`
and even include graphics.

"""
import collections

try:
    from mayavi import mlab
except:
    print( " WAS not able to load mayavi, some feature might be missing ")

import string

import numpy as np
import math

import yaml
from yaml import load, dump

import numbers
import re
import yaml
import yaml.resolver
import PyMca5.PyMcaIO.specfilewrapper as SpecIO
import fabio
from six import u


from silx.gui  import qt as Qt
## from  PyQt4 import Qt, QtCore
from XRStools.roiNmaSelectionGui   import roiNmaSelectionWidget
from XRStools import roiSelectionWidget

import h5py
import sys

yaml.resolver.Resolver
Resolver = yaml.resolver.Resolver
Resolver.add_implicit_resolver(
        u'tag:yaml.org,2002:float',
        re.compile(u(r"""^(?:[-+]?(?:[0-9][0-9_]*)(\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?
                    |\.[0-9_]+(?:[eE][-+][0-9]+)?
                    |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*
                    |[-+]?\.(?:inf|Inf|INF)
                    |\.(?:nan|NaN|NAN))$"""), re.X),
        list(u'-+0123456789.'))

try:
    from mpi4py import MPI
    myrank = MPI.COMM_WORLD.Get_rank()
    nprocs = MPI.COMM_WORLD.Get_size()
    procnm = MPI.Get_processor_name()
    comm = MPI.COMM_WORLD
    print( "MPI LOADED , nprocs = ", nprocs)
except:
    class FakeComm:
        def Barrier(self):
            pass
        def allreduce(self,number, operation):
            assert ( isinstance(number, numbers.Number)    )
            return number
        def Get_size(self):
            return 1

    myrank=0
    nprocs = 1
    comm = FakeComm()
    print( "no MPI LOADED , nprocs = ", nprocs)



def stripROI(t):
    if "ROI" in t:
        return t[3:]
    else:
        return t

def filterRoiList(l, strip=False, prefix="ROI"):
    
    if strip:
        result =  [ str(int(stripROI(t))) for t in l if ( t not in [ "motorDict", "response"] and t[:len(prefix)]==prefix )]
    else:
        result =  [ t for t in l  if ( t not in [ "motorDict", "response"] and  t[:len(prefix)]==prefix ) ]


    result  =      sorted(  result     , key = lambda x:  int(''.join(filter(str.isdigit, str(x) ))) )
    ### result.sort()
    
    return result

def filterScanList(l, prefix="Scan"):
    result =  [ t for t in l  if ( t not in [ "motorDict", "response"] and t[:len(prefix)]==prefix ) ]

    result = sorted(  result     , key = lambda x:  int(''.join(filter(str.isdigit, str(x) ))) )
    # result.sort()
    
    return result
    

def checkNoParallel( routineName):
    if nprocs>1:
        msg = " ERROR : %s feature not yet parallel : relaunch it with 1 process only "
        print( msg)
        raise Exception( msg)

# try:
#     from yaml import CLoader as Loader, CDumper as Dumper
# except ImportError:
#     from yaml import Loader, Dumper            




nprocs = comm.Get_size()

if nprocs>1:
    # circumvent issus with mpi4py not stopping mpirun
    def excepthook(type, value, traceback):
        res = sys.__excepthook__(type, value, traceback)
        comm.Abort(1)
        return res
    sys.excepthook=excepthook



import os
from XRStools import xrs_rois
from XRStools import roifinder_and_gui
from XRStools import xrs_scans
from XRStools import xrs_read
from XRStools import rixs_read
from XRStools import theory
from XRStools import extraction

from XRStools import xrs_prediction
from XRStools import xrs_imaging


from XRStools import xrs_imaging
from XRStools import superr

#################################################################
##  THIS redefinition of yaml is used to keep the entry ordering
## when accessing yamlData keys
##
#yaml_anydict.py
import yaml
from yaml.representer import Representer
from yaml.constructor import Constructor, MappingNode, ConstructorError

from XRStools import fit_spectra
from XRStools import reponse_percussionelle



def check_allowed_keys(  mydata, allowed_keys  ) :
    for k in mydata.keys():
        if not k in allowed_keys:
            raise ValueError( (" key "+str(k) +" not in allowed keys :"+ str(allowed_keys))  )
    
def dump_anydict_as_map( anydict):
    yaml.add_representer( anydict, _represent_dictorder)
def _represent_dictorder( self, data):
    return self.represent_mapping('tag:yaml.org,2002:map', data.items() )

class Loader_map_as_anydict( object):
    'inherit + Loader'
    anydict = None      #override
    @classmethod        #and call this
    def load_map_as_anydict( klas):
        yaml.add_constructor( 'tag:yaml.org,2002:map', klas.construct_yaml_map)

    'copied from constructor.BaseConstructor, replacing {} with self.anydict()'
    def construct_mapping(self, node, deep=False):
        if not isinstance(node, MappingNode):
            raise ConstructorError(None, None,
                    "expected a mapping node, but found %s" % node.id,
                    node.start_mark)
        mapping = self.anydict()
        for key_node, value_node in node.value:
            key = self.construct_object(key_node, deep=deep)
            try:
                hash(key)
            except TypeError as exc:
                raise ConstructorError("while constructing a mapping", node.start_mark,
                        "found unacceptable key (%s)" % exc, key_node.start_mark)
            value = self.construct_object(value_node, deep=deep)
            mapping[key] = value
        return mapping

    def construct_yaml_map( self, node):
        data = self.anydict()
        yield data
        value = self.construct_mapping(node)
        data.update(value)


class myOrderedDict (collections.OrderedDict):
    def __setitem__(self,a,b):
        if type(a)==type("") and a in self:
            self[a+"_TAG_this_key_is_given_twice"]=b 
        else:
            ## print super(myOrderedDict, self)
            super(myOrderedDict, self).__setitem__(a,b )


def cleaned(key):
    while key[-28:]=="_TAG_this_key_is_given_twice":
        key=key[:-8]
    return key
  

            
dictOrder = myOrderedDict

class Loader( Loader_map_as_anydict, yaml.Loader):
    anydict = dictOrder
Loader.load_map_as_anydict()
dump_anydict_as_map( dictOrder)


##
## END of yaml redefinition
###############################

def check_libre( h5 , groupname   ) :

    print("check_libre DESACTIVATED. RESULTS CAN BE OVERWRITTEN")
    return

    if type(h5)==type(""):
        h5f = h5py.File(h5, "r"  )
        h5f.close()
        if groupname in h5f:
            msg=(("ERROR: %s key already present in the hdf5 file %s. Erase it before if you dont need it.\n" % (groupname, h5))*10 )
            print( msg)
            raise Exception( msg)
        else:
            if groupname in h5:
                msg = (("ERROR: %s key already present in the hdf5 file. Erase it before if you dont need it.\n"%groupname)*10 )
                print( msg)
                raise Exception( msg)



inputtext=""

def yamlFileToDic(fn):
    global  inputtext
    filename = fn
    inputfile = open(filename,"r")
    yamlData = load(inputfile, Loader=Loader)
    return yamlData
    

def main():
    global  inputtext
    filename = sys.argv[1]

    inputfile = open(filename,"r")
    yamlData = load(inputfile, Loader=Loader)
    inputtext = open(filename,"r").read()

    for key in list(yamlData.keys()):
      
        mydata = yamlData[key]
        if isinstance(mydata,dict) and    "active"  in mydata :
            if mydata["active"]==0:
                continue

        if key != "help":
            swissknife_operations[cleaned(key)](  mydata )
        else:

            if cleaned(key)  not in parallelised_operations:
                checkNoParallel( cleaned(key)  )
            
            swissknife_operations[cleaned(key)]( yamlData  )
    
    # workbench_file = yamlData["workbench_file"]


def help(yamlData):
    """
    **help**

    Displays doc on the operations. In the input file ::

       help :

    will trigger printing of all the available operation names ::

       help :
           create_rois
           load_scans

    will print the help on *create_rois* and the help about *load_scans*.
    By the way, it is the same that you can read here because the *sphinx* doc-generation tool
    reads the same docstrings contained in the code.
     
    """
    print( " HELP " *15)
    if yamlData ["help"] is None:
        print( """
              Printing all the function names
              To get help on a specific function:

              help : "functionName"
        """)
        for key,func in swissknife_operations.items():
            print( " FUNCTION : " , key)

    else:
        func = swissknife_operations[ yamlData ["help"]]
        print( "---------------------------------------")
        print( func.__doc__)



def split_hdf5_address(dataadress):
 
    pos = dataadress.rfind(":")
    if ( pos==-1):
        raise Exception( """
roiaddress   must be given in the form  roiaddress : "myfile.hdf5:/path/to/hdf5/group"
but : was not found
""")
    filename, groupname = dataadress[:pos], dataadress[pos+1:]
    if( len(groupname) and groupname[0:1] !="/" ):
        groupname = "/"+groupname
    return filename, groupname 


    
# def load_scans(mydata):
#     """
#     **load_scans**

#     This command harvest the selected signals.
#     the instructions on the scans to be taken must be in the form( as submembers ofload_scans ) ::


#      load_scans :
#          roiaddress :  "hdf5filename:nameofroigroup"  # the same given in create_rois
#          expdata    :  "absolutepathtoaspecfile"  # this points to a spec file

#          elastic_scans    : [623]
#          fine_scans       : [626,630,634,638,642]
#          n_loop           : 4
#          long_scan        : 624

#          signaladdress : "nameofsignalgroup"  # Target group for writing Relative to ROI (and in the same file)!!!!

#          #############################################################
#          # OPTIONALS
#          #
#          order : [0,1,2,3,4,5]  #  list of integers (0-5) which describes the order of modules in which the 
#                                 #    ROIs were defined (default is VD, VU, VB, HR, HL, HB; i.e. [0,1,2,3,4,5])

#          rvd : -41              # mean tth angle of HL module (default is 0.0)
#          rvu : 85               # mean tth angle of HR module (default is 0.0)
#          rvb : 121.8            # mean tth angle of HB module (default is 0.0)
#          rhl : 41.0             # mean tth angle of VD module (default is 0.0)
#          rhr : 41.0             # mean tth angle of VU module (default is 0.0)
#          rhb : 121.8            # mean tth angle of VB module (default is 0.0)


#     #
#     """

#     roiaddress=None
#     roiaddress = mydata["roiaddress"]

#     filename, groupname = split_hdf5_address (roiaddress)
#     file= h5py.File(filename,"r")
#     rois = {}
#     shape=xrs_rois.load_rois_fromh5(file[groupname],rois)
#     file.close()

#     roiob = xrs_rois.roi_object()
#     roiob.load_rois_fromMasksDict(rois ,  newshape = shape, kind="zoom")
    
#     reader = xrs_read.read_id20(mydata["expdata"] , monitorcolumn='kapraman')


#     reader.set_roiObj(roiob)

#     elastic_scans   =  mydata["elastic_scans"][:] 
#     fine_scans      =  mydata["fine_scans"][:] 
#     n_loop          =  mydata["n_loop"] 
#     long_scan       =  mydata["long_scan"]

#     reader.loadelasticdirect(elastic_scans)
#     reader.loadloopdirect(fine_scans,n_loop)
#     print( " LUNGO " )
#     reader.loadlongdirect(long_scan)

    

#     reader.getspectrum()

#     reader.geteloss()
#     reader.gettths(
#         rvd   = gvord(mydata,"rvd",0.0) ,
#         rvu   = gvord(mydata,"rvu",0.0) ,
#         rvb   = gvord(mydata,"rvb",0.0) ,
#         rhl   = gvord(mydata,"rhl",0.0) ,
#         rhr   = gvord(mydata,"rhr",0.0) ,
#         rhb   = gvord(mydata,"rhb",0.0) ,
#         order = gvord(mydata,"order",        [0,1,2,3,4,5])
#         )

#     groupname = groupname+"/"+ mydata["signaladdress"]
#     check_libre( filename , groupname   ) 

#     reader.save_state_hdf5( filename, groupname , comment = inputtext )





# def volume_from_2Dimages(mydata):
#     """
#     imagesaddress :  "test_imaging.hdf5:/ROI_A/images"  # where the data have been saved

#     scan_interval    :  [372,375]                    # OPTIONAL : can be shorter then the scans effectively present in the file
#     roi_n            : 0           # OPTIONAL. if not given, the first non empty found roi. Starts from 0

#     imagesaddress : "myfile.hdf5:/path/to/hdf5/data"  # OPTIONAL. the target destination for volume. if not given mayavi is launched on the fly.

#     """


#     reader = xrs_imaging.oneD_imaging( "bidon"  , "bidon",  "bidon"  , "bidon")


#     imagesaddress = mydata["imagesaddress"]
#     filename, groupname = split_hdf5_address(imagesaddress)

#     reader.load_state_hdf5( filename, groupname)

#     scan_names = list( reader.twoDimages.keys() )
#     scan_ids = map(int, [name[4:] for name in scan_names  ] )
#     order = np.argsort(scan_ids)

#     if not  ('scan_interval') in mydata :
#         scan_names = [  scan_names[id] for id in order ] 
#     else:
#         scan_interval = mydata['scan_interval']

#         print( order)
#         print( scan_names)
#         print( scan_interval)
#         scan_names = [  scan_names[id] for id in order if scan_ids[id]>=scan_interval[0] and scan_ids[id]<scan_interval[1]  ] 
    
#     first_name = scan_names[0]
#     roi_n=0
    
#     if not  ('roi_n' in mydata ):
#         while(1):
#             shape  = reader.twoDimages[first_name][roi_n].matrix.shape
#             if shape != (0,) : 
#                 break
#             roi_n+=1
#     else:
#         roi_n = mydata["roi_n"]
#         shape  = reader.twoDimages[first_name][roi_n].matrix.shape
            
#     Volume  = np.zeros((     shape[0],  shape[1]   ,     len(scan_names)    ))

#     for i,scanname  in enumerate(scan_names):
#         Volume[:,:,i] = reader.twoDimages[scanname][roi_n].matrix

#     if   ('volumeaddress') in mydata :
#         filename, groupname = split_hdf5_address( mydata['volumeaddress'] )

#         h5=h5py.File(filename,'a')
#         check_libre( h5 , groupname   ) 
#         h5[groupname] = Volume
#         h5.close()
#         h5=None
#     else:
#        view_Volume_myavi_(Volume) 



# def view_Volume_myavi(mydata):
#     """
#     volume_address : "myfile.hdf5:/path/to/hdf5/group"  # the target destination for volume. 
#     """


#     filename, groupname = split_hdf5_address( mydata['volume_address'] )
#     h5=h5py.File(filename,'r')
#     Volume = h5[groupname] [:]
#     h5.close()
#     h5=None


#     isolevel = mydata['isolevel']
#     opacity = mydata['opacity']

    
#     view_Volume_myavi_(Volume,  isolevel, opacity)
    


# def view_Volume_myavi_(V,  isolevel, opacity) :
#     print( " IN view ")
#     src = mlab.pipeline.scalar_field(V)
#     mlab.pipeline.iso_surface(src, contours=[V.min()+isolevel*V.ptp(), ], opacity=opacity)
#     mlab.show()
#     src = mlab.pipeline.scalar_field(V)
#     mlab.pipeline.volume(src,vmin=1000.0, vmax=2000.0)
#     mlab.show()


def calculate_recenterings(mydata):
    """
    **calculate_recenterings**

    calculates offsets to go from baricenter A to baricenter B, for all the rois
    in 
 

      calculate_recenterings:
         bariA : "demo_rois.h5:/ROI_AS_SELECTED/images_broad/scans/scan342"
         bariB : "demo_rois.h5:/ROI_AS_SELECTED/energy_scan/scans/scan237"
         target: "recenterings.h5:/recenterings4rois" 
    #
    """
    allowed_keys =["bariA","bariB","target",   ]
    check_allowed_keys(mydata, allowed_keys)
    
    bariA = mydata["bariA"]
    bariA_filename, bariA_groupname = split_hdf5_address( bariA )
    
    bariB = mydata["bariB"]
    bariB_filename, bariB_groupname = split_hdf5_address( bariB )

    target = mydata["target"]
    target_filename, target_groupname = split_hdf5_address( target )

    print( bariA_filename, bariA_groupname)
    print( " OPENIN FILE ", bariA_filename  , " FOR RECENTERING ")
    h5A_f = h5py.File(bariA_filename,"r")
    h5A = h5A_f [bariA_groupname]
    if bariB_filename == bariA_filename :
        h5B_f =  h5A_f
    else:
        h5B_f=h5py.File(bariB_filename,"r")
        
    h5B = h5B_f[bariB_groupname]
    offs = {}

    chiavi = filterRoiList(h5A.keys(), prefix="")
    for c in chiavi:
        bA = h5A[c]["barix"][()] + h5A[c]["cornerpos"][:][1]
        bB = h5B[c]["barix"][()] + h5B[c]["cornerpos"][:][1]
        bAy = h5A[c]["bariy"][()] + h5A[c]["cornerpos"][:][0]
        bBy = h5B[c]["bariy"][()] + h5B[c]["cornerpos"][:][0]
        offs[c] = [[bBy, bAy ],[bB,bA]]
        
    if h5B_f is not h5A_f:
        h5B_f.close()
    h5A_f.close()


    if os.path.exists(target_filename):
        # check_libre( target_filename ,  target_groupname  )
        h5f = h5py.File(target_filename,"a")
        if target_groupname in h5f:
            del h5f[target_groupname]

        
    else:
        h5f = h5py.File(target_filename,"w")
    h5f.require_group(  target_groupname  )
    h5 = h5f[target_groupname]
    for c in chiavi :
       h5[c] = np.array(  offs[c]    )
    h5f.flush()
    h5f.close()
    h5f = None


# def     sum_scans2maps(mydata):

#     roiaddress=None
#     roiaddress = mydata["mask_file"]
  
#     filename, groupname = split_hdf5_address( roiaddress)

#     file= h5py.File(filename,"r")
#     rois = {}
#     shape=xrs_rois.load_rois_fromh5(file[groupname],rois)
#     file.close()
 
#     specfile_name = mydata["spec_file"]
#     Scan_Variable = mydata["Scan_Variable"]
#     Motor_Variable = mydata["Motor_Variable"]

    
#     specfile = SpecIO.Specfile( specfile_name )


#     dirname  = os.path.dirname(   specfile_name )   
#     basename = os.path.basename(   specfile_name )  

    
#     scans_infos = []
#     signals    = []

#     s1 = int(mydata["first_scan"])
#     s2 = int(mydata["last_scan"])

#     roi_names = list(rois.keys())
#     roi_list = [  rois[k] for k in roi_names  ]
    
#     for i in range(s1,s2+1):
#         # print " SCAN lettura " , i
#         scan = specfile.select(str(i))
#         scan_data = scan.data()
        
#         scan_themotor   =  scan.motorpos( Motor_Variable  )
#         scan_othermotors = [ scan.motorpos( name   )  for name in  scan.allmotors()  if name != Motor_Variable   ]

#         othermotorsname = [name for name in  scan.allmotors()  if name != Motor_Variable]
        
#         labels = scan.alllabels()
#         scan_variable = scan_data[ labels.index( Scan_Variable )   , :]
#         scan_ccdnos  = scan_data[ labels.index( "ccdno" )   , :].astype("i")
#         signal = []
#         for no in scan_ccdnos:
#             print( " opening image ", os.path.join(   dirname   ,  "edf", basename+"_"+str(no)+".edf"))
#             data = fabio.open(  os.path.join(   dirname   ,  "edf", basename+"_"+str(no)+".edf" )   ).data 
#             tok = [ (data[corner[0]:corner[0]+mask.shape[0],   corner[1]:corner[1]+mask.shape[1]]*mask).sum() for corner, mask in roi_list  ]
#             signal.append(tok)
#             # print " OK "


#         # print signal
#         # print " Appendo " , signal

    
#         signals.append(np.array(signal))
#         # print "OK " 
#         scans_infos.append( [scan_themotor, scan_othermotors,  scan_variable  ]  )

#         # print " DONE scan " , i
        
#     done = np.zeros( len(scans_infos) ,"i")
#     DONE={}
#     synthes = {}
#     for kscan in range(len(scans_infos) ):
#         # print " kscan " , kscan
#         DONE[kscan]=0
#         if done[kscan]:
#             continue
#         else:
#             res  = np.array(signals[kscan])
            
#             done[kscan]=1
#             kinfos = scans_infos[kscan]
#             kM, kOM,  kV = kinfos
            
#             for oscan in  range(len(scans_infos)) :
#                 # print " oscan " , oscan
#                 if done[oscan]:
#                     continue
#                 else:
#                     oinfos = scans_infos[oscan]
                    
#                     oM, oOM,  oV = oinfos

#                     if kM==oM:
#                         if True or (np.abs(np.array(kOM)-np.array(oOM)).sum()==0.0):
#                             print( " SONO UGUALI " )
#                             if len(oV)== len(kV) :
# #                                   if  np.abs(kV-oV).sum()==0.0:
#                                     print( " AGGIUNGO " )
#                                     res = res+np.array(signals[oscan])
#                                     done[oscan]=1


#             print( " AGGIUNGO " , kM, len(kV), len(kOM))
#             synthes[kscan] = [  kM, kV, kOM, res  ]
#             done[kscan]    = 1


#     # print " QUI " 

#     target = mydata["scans_file"]
#     target_filename, target_groupname = split_hdf5_address( target)
#     if os.path.exists(target_filename):
#         h5f = h5py.File(target_filename,"a")
#     else:
#         h5f = h5py.File(target_filename,"w")
#     h5 = h5f.require_group(target_groupname)
#     target_subdir = "collection_"+str(s1)+"_"+str(s2)
#     if target_subdir in  h5:
#         del h5[ target_subdir]
        
#     h5 =  h5.require_group(target_subdir)
            
#     for kscan in    list(synthes.keys() ):
#         if DONE[kscan] :
#             continue
        
#         kM, kV, kOM, kdata  = synthes[kscan] 

#         # print " kdata.shape" , kdata.shape
         
        
#         myscans = [kdata]
#         myM     = [kM    ]
#         myV     = [kV    ]
#         DONE[kscan] = 1

#         for oscan in    list(synthes.keys() ):
#             if DONE[oscan]:
#                 continue
#             else:
#                 oM, oV, oOM, odata  = synthes[oscan]
#                 # print " COMPARO "
#                 # diff =  np.array(kOM)-np.array(oOM)
#                 # for nn ,dd in zip(othermotorsname, diff    ):
#                 #     if dd >0.0:
#                 #         print nn, dd
#                 if True or (np.abs(np.array(kOM)-np.array(oOM)).sum()==0.0):
#                     print( " OM equal " ,  len(kV) , len(oV))
#                     if( len(kV) == len(oV)):
#                       # print np.abs(kV-oV)
#                       # if np.abs(kV-oV).sum()==0.0:

#                         assert( kM!=oM  )
#                         DONE[oscan]=1

#                         # print " odata.shape " ,  odata.shape
                        
#                         myscans.append(odata)

#                         # print "  myscans.shape " , np.array(myscans).shape
                        
#                         myM.append(oM)
#                         myV.append(oV)
#         DONE[kscan]=1 
#         myscans = np.array(myscans)



#         if len(myM)>1:
#             order = np.argsort(myM)
#             myM     = np.array(myM)[order]
#             myscans = np.array(myscans)[order]
#             myV     = np.array(myV)
#         else:
#             myM     = np.array(myM)
#             myV     = np.array(myV)
            
#         ts = "scan_"+str(int(s1)+kscan)
#         h5t = h5.require_group(ts)

#         h5t["Variable"] = myV
#         h5t["Motor"]    = myM

#         s="f, axarr = pylab.plt.subplots(%d, sharex=True)\n"%len(roi_names)

#         ly = myM[0]
#         hy = myM[-1]

#         if (  np.abs(myV[-1,:]-myV[0,:]).sum()==0.0 ):
#               xlabel =  "An. Energy"
#               lx = myV[0,0]
#               hx = myV[0,-1]
#         else:
#               xlabel =  "Energy Loss"
#               diff = myM[0]- myV[0,:]
#               lx =  diff[0]
#               hx =  diff[-1]


              
#         for i,rn in enumerate(roi_names):
#             tok = myscans[:,:,i]
#             h5t["signal_"+rn] = tok
            
#             s=s+"axarr[%d].imshow( %s ,extent=( %e ,%e ,%e ,%e) ) \n"%(i, "self.signal_"+rn, lx,hx,ly,hy)
#             s=s+"axarr[%d].set_title('%s')\n"%(i,rn)
#             if i==0:
#                 s=s+"axarr[%d].set_xlabel('%s')\n"%(i,xlabel)
            
#         s=s+"pylab.plt.show()\n"
#         h5t["python_plot"]=s
                                                                        
#     h5f.flush()
#     h5f.close()

        
        
# """
#      sum_scans2maps :
#  spec_file : /mntdirect/_data_visitor/hc2892/id20/run7_hc2892/rixs
#  first_scan : 127
#  last_scan : 136
#  Scan_Variable : Anal Energy
#  Motor_Variable : energy
#  scans_file : /scisoft/users/mirone/WORKS/matlabID20/rawdata/scansfile.h5:SCAN
# """  

def loadscan_2Dimages(mydata):
    """
    **loadscan_2Dimages**

    This command harvest the selected signals.
    the instructions on the scans to be taken must be in the form( as submembers ofload_scans ) ::


      loadscan_2Dimages :
         roiaddress :  "hdf5filename:nameofroigroup"  # the same given in create_rois
         expdata    :  "absolutepathtoaspecfile"  # this points to a spec file

         scan_interval    :  [372,423]   # from 372 to 422 included

         signaladdress : "nameofsignalgroup"  # Target group for writing Relative to nameofroigroup/ (and in the same file)!!!!
                                              # unless it is in the format filename:groupname

         energycolumn : 'sty'        # OPTIONAL, if not give defaults to sty
         monitorcolumn : 'kapraman'  # OPTIONAL , default is kapraman. If the key is not found in spec file, then no normalisation will be done
                                     # You can also write kapraman/1000 in this case the monito will be divided by 1000
                                     # (or the other number that you write)
         edfName    :  'edfprefix'   # OPTIONAL, if not given autonmatically determined

         sumto1D  : 1  # OPTIONAL, default 0

         isolateSpot : 0   # is different from zero selects on each image  ( when sumto1d=0 ) ROI  the spot region and sets to zero outside a radius =  isolateSpot

         # the following defaults to None
         recenterings : "recenterings.h5:/recenterings4rois"
 
    #
    """
    allowed_keys = ["roiaddress", 'monitorcolumn', 'recenterings', 'recenterings_confirmed', 'energycolumn', 'edfName', 'isolateSpot', "expdata","scan_interval","scan_list","signaladdress","save_also_roi", 'sumto1D',]
    check_allowed_keys(mydata, allowed_keys)


    
    roiaddress=None
    roiaddress = mydata["roiaddress"]
  
    filename, groupname = split_hdf5_address( roiaddress)

    file= h5py.File(filename,"r")
    rois = {}
    shape=xrs_rois.load_rois_fromh5(file[groupname],rois)
    file.close()

    roiob = xrs_rois.roi_object()
    roiob.load_rois_fromMasksDict(rois ,  newshape = shape, kind="zoom")

    monitor_divider = 1.0
    
    if  ('monitorcolumn') in mydata :
        monitorcolumn = mydata['monitorcolumn']
    else:
        monitorcolumn = 'kapraman'

    pos = monitorcolumn.find("/")
    if pos != -1:
        monitor_divider = float(monitorcolumn[pos+1:])
        monitorcolumn = monitorcolumn[:pos]

    print( "monitorcolumn : " , monitorcolumn)
    print( "monitor_divider : " , monitor_divider)
        
    is_by_refinement =False
    if  ('recenterings') in mydata :
        recenterings = mydata['recenterings']
        recenterings_filename, recenterings_groupname = split_hdf5_address( recenterings )
        h5f = h5py.File(recenterings_filename,"r")
        h5 = h5f[recenterings_groupname]
        recenterings= {}
        chiavi = filterRoiList(h5.keys(), prefix="")
        for c in chiavi:
            recenterings[int(c)]= h5[c][:]
            if recenterings[int(c)].shape == (2,2):
                if nprocs>1:
                    raise Exception("When using recentering with refinement parallelism cannote be used")
                is_by_refinement = True
        h5f.close()
        if is_by_refinement:
            recenterings_confirmed = mydata['recenterings_confirmed']
            recenterings_confirmed_filename, recenterings_confirmed_groupname = split_hdf5_address( recenterings_confirmed )
           
    else:
        recenterings = None

        
    if  ('energycolumn') in mydata :
       energycolumn  = mydata['energycolumn']
    else:
       energycolumn  = 'sty'

    if  ('edfName') in mydata :
        edfName = mydata['edfName']
    else:
       edfName  = None

    if  ('sumto1D') in mydata :
        sumto1D = mydata['sumto1D']
    else:
        sumto1D  = 0
        
    if  ('isolateSpot') in mydata :
        isolateSpot = mydata['isolateSpot']
    else:
        isolateSpot  = 0

    
    reader = xrs_imaging.oneD_imaging( mydata["expdata"]  ,monitorcolumn = monitorcolumn , monitor_divider=monitor_divider,
                                       energycolumn = energycolumn  , edfName = edfName, sumto1D = sumto1D,
                                       recenterings=recenterings)
    reader.set_roiObj(roiob)


    todo_list = []
    if "scan_interval" in mydata:
        scan_interval = mydata["scan_interval"]
        ninterval = len(scan_interval)//2
        for i in range(ninterval):
            todo_list = todo_list + list(range(    int(scan_interval[2*i]),  int(scan_interval[2*i+1])) ) #   *scan_interval[2*i :2*i+2])
    else:
        scan_list = mydata["scan_list"]
        for i in scan_list:
            todo_list = todo_list + [int(i)]
        


    mytodo = np.array_split(todo_list, nprocs) [myrank]
    print(  " Process ", myrank, " is going to read the following scans ", mytodo)
    maxvalue=0.0
    if(len(mytodo)):
        maxvalue = reader.loadscan_2Dimages( list(mytodo) ,scantype=energycolumn, isolateSpot = isolateSpot)
    if nprocs>1:
        maxvalue = comm.allreduce(maxvalue, op=MPI.MAX)

    if is_by_refinement :
        if nprocs>1:
            raise Exception("When using recentering with refinement parallelism cannote be used")
        if os.path.exists(recenterings_confirmed_filename):
            check_libre(  recenterings_confirmed_filename    , recenterings_confirmed_groupname       )

            h5f = h5py.File(recenterings_confirmed_filename,"a")
        else: