tut/integrate_new_operator/NewFFT.py

Go to the documentation of this file.

from slimpy_base.Core.User.linop.rclinOp import linearop_r as LinearOperatorStruct
from numpy import ceil
from slimpy_base.api.Plugins.slim2rsf.sfCommandFactory import rsfCommandFactory
from slimpy_base.api.Plugins.slim2rsf.sfcommands.sfConverter import sfConverter

########################################################################
# Define how fftx behaves
########################################################################

# create a Converter class
class fftX_Converter( sfConverter ):
    """
    This is a mapping instance that maps a SLIMpy command into an object that 
    can be run 
    This also maps the agruments and keyword arguments to be pugin specific
    """
    # alwas use classmethod or static method
    @classmethod
    def map( cls, source, command ):
        """
        map a SLIMpy command to a rsf command
        """
        # the RSF bin and 'sf' will be automaticaly prepended to fft1
        command = cls.default_function( command, "fft1" ) 
        #change all python True/False objects to 'y'/'n' strings
        command = cls.truefalseHelper( command )
        #map the adj flage to inv
        command = cls.keywordmap( command, {'adj':'inv'} )
        #alwas must return a CommandPack instance
        return cls.pack( command )
    

    @classmethod
    def trans( cls, command, space, *spaces ):
        'define how this operator affect the space'
        n1 = spaces[0]['n1']
        space['n1_fft']= n1
        space["n1"] = int( ceil( n1/2. )+1 )
        space['data_type']='float' 
        return space
    
    @classmethod
    def trans_adj( cls, command, space, *spaces ):
        """
        trans_adj will automatically be called in the case
        where the command has an adj keyword that is true
        """
        n1 = spaces[0]['n1_fft']
        space['data_type']='complex'
        space['n1']= n1
        return space
    
    @classmethod
    def constr( cls, command, space ):
        'make sure the data on the forward command is float'
        cls.match( space, data_type='float' )
    @classmethod
    def constr_adj( cls, command, space ):
        'make sure the data on the adjoint command is complex'
        cls.match( space, data_type='complex' )


#===============================================================================
# Linear operator class itself 
#===============================================================================
class fft1X( LinearOperatorStruct ):
    """
    Fourier transfrorm on the first axis
    """
    name = "fftX"
    
    def __init__( self, inSpace, sym=True, opt=False ):
        
        kparams = dict( sym=sym, opt=opt, adj=False )

        LinearOperatorStruct.__init__( self, inSpace, **kparams )

#===============================================================================
# Add it to the list of existing rsf commands  
#===============================================================================

factory = rsfCommandFactory()
# add the converter class to the factory
# now converter will be invoked when 
# a linear operator with the 'name' attribute
# of fftX
factory['fftX'] = fftX_Converter

---