import phaser

def mr_rlist_getinitargs(self):
    
    return ( self.MODLID, self.EULER, self.RF, self.RFZ )


def mr_ndim_getinitargs(self):
    
    return (
        self.getModlid(),
        self.getR(),
        self.getFrac(),
        self.getInFrac(),
        self.getFracT(),
        self.getBfac(),
        self.getFixR(),
        self.getFixT(),
        self.getFixB(),
        )
    
    
def MapCoefs_getinitargs(self):
    
    return (
        self.FC,
        self.PHIC,
        self.FWT,
        self.PHWT,
        self.DELFWT,
        self.PHDELWT,
        self.FOM,
        self.HLA,
        self.HLB,
        self.HLC,
        self.HLD,
        )
    
    
def mr_set_getinitargs(self):
    
    return (
        self.ANNOTATION,
        self.KNOWN,
        self.RLIST,
        self.TF,
        self.TFZ,
        self.LLG,
        self.ORIG_LLG,
        self.R,
        self.ORIG_R,
        self.PAK,
        self.ORIG_NUM,
        self.KEEP,
        self.EQUIV,
        self.TMPLT,
        self.MAPCOEFS,
        self.NEWVRMS,
        self.HALL,
        self.TFZeq,
        )
    
    
def mr_solution_getinitargs(self):
    
    return (
        list( self ),
        )
    
    
def SpaceGroup_getstate(self):
    
    return {
        "space_group_hall": self.getSpaceGroupHall(),
        }
    

def SpaceGroup_setstate(self, state):
    
    assert "space_group_hall" in state
    self.setSpaceGroupHall( state[ "space_group_hall" ] )
    

def UnitCell_getstate(self):
    
    return {
        "unit_cell": self.getUnitCell(),
        }
    
    
def UnitCell_setstate(self, state):
    
    assert "unit_cell" in state
    self.setUnitCell( state[ "unit_cell" ] )
    
    
def Output_getstate(self):
    
    return {
        "summary": self.summary(),
        "logfile": self.logfile(),
        "verbose": self.verbose(),
        }
    
    
def Output_setstate(self, state):
    
    assert "summary" in state
    assert "logfile" in state
    assert "verbose" in state
    
    self.setStrings(
        summary = state[ "summary" ],
        logfile = state[ "logfile" ],
        verbose = state[ "verbose" ],
        )
    
    
def data_refl_getinitargs(self):
    
    return (
        self.MILLER,
        self.FMEAN,
        self.SIGFMEAN,
        )
    
    
def scatterer_extra_getstate(self):
    
    return {
        "REJECTED": self.REJECTED,
        "RESTORED": self.RESTORED,
        "n_adp": self.n_adp,
        "n_xyz": self.n_xyz,
        }
    
    
def scatterer_extra_setstate(self, state):
    
    self.REJECTED = state[ "REJECTED" ]
    self.RESTORED = state[ "RESTORED" ]
    self.n_adp = state[ "n_adp" ]
    self.n_xyz = state[ "n_xyz" ]
    

def DataA_getinitargs(self):
    
    return (
        self.getUnitCell(),
        phaser.data_refl( self.getMiller(), self.getF(), self.getSIGF() ),
        phaser.data_resharp(),
        )
    
    
def ResultANO_getinitargs(self):
    
    return (
        phaser.Output(),
        )
    
    
def ResultANO_getstate(self):
    
    d = Output_getstate( self )
    d.update(
        {
            "data_a": phaser.DataA(
                self.getUnitCell(),
                phaser.data_refl( self.getMiller(), self.getF(), self.getSIGF() ),
                phaser.data_resharp(),
                ),
            "data_a_wilson_k": self.getWilsonK(),
            "data_a_wilson_b": self.getWilsonB(),
            "data_a_aniso": self.getANISO(),
            }
        )
    
    return d


def ResultANO_setstate(self, state):
    
    assert all( label in state for label in [ "data_a" ] )
    
    self.setDataA( state[ "data_a" ] )
    self.setANISO( state[ "data_a_aniso" ] )
    self.setWilsonB( state[ "data_a_wilson_b" ] )
    self.setWilsonK( state[ "data_a_wilson_k" ] )
    Output_setstate( self, state )
    
    
def ResultMR_getinitargs(self):
    
    return (
        phaser.Output(),
        )
    
    
def ResultMR_getstate(self):
    
    d = Output_getstate( self )
    d.update(
        {
            "init": (
                self.getResultType(),
                self.getTitle(),
                self.getNumTop(),
                phaser.map_string_data_pdb(),
                phaser.map_string_data_map(),
                ),
            "mr_set": self.getDotSol(),
            "data_a": phaser.DataA(
                self.getUnitCell(),
                phaser.data_refl( self.getMiller(), self.getF(), self.getSIGF() ),
                phaser.data_resharp(),
                ),
            }
        )
    
    return d


def ResultMR_setstate(self, state):
    
    assert all( label in state for label in [ "init", "mr_set", "data_a" ] )
    
    self.init( *state[ "init" ] )
    self.setDotSol( state[ "mr_set" ] )
    self.setDataA( state[ "data_a" ] )
    Output_setstate( self, state )
    
    
def ResultMR_RF_getinitargs(self):
    
    return (
        phaser.Output(),
        )
    
def ResultMR_RF_getstate(self):
    
    d = Output_getstate( self )
    d.update( UnitCell_getstate( self ) )
    d.update(
        {
            "rlist": self.getDotRlist(),
            "init": (
                self.getHall(),
                self.getTitle(),
                self.getNumTop(),
                phaser.map_string_data_pdb(),
                phaser.map_string_data_map(),
                )
            }
        )
    
    return d


def ResultMR_RF_setstate(self, state):
    
    assert "rlist" in state and "init" in state
    
    self.init( *state[ "init" ] )
    self.setDotRlist( state[ "rlist" ] )
    Output_setstate( self, state )
    UnitCell_setstate( self, state )
    
    
def ResultMR_TF_getinitargs(self):
    
    return (
        phaser.Output(),
        )
    
def ResultMR_TF_getstate(self):
    
    d = Output_getstate( self )
    d.update( UnitCell_getstate( self ) )
    d.update(
        {
            "dot_sol": self.getDotSol(),
            "init": (
                self.getTitle(),
                self.getNumTop(),
                phaser.map_string_data_pdb(),
                phaser.map_string_data_map(),
                )
            }
        )
    
    return d


def ResultMR_TF_setstate(self, state):
    
    assert "dot_sol" in state and "init" in state
    
    self.init( *state[ "init" ] )
    self.setDotSol( state[ "dot_sol" ] )
    Output_setstate( self, state )
    UnitCell_setstate( self, state )
    
    
def BinStats_getstate(self):
    
    state = {}
    state[ "NUM_bin" ] =  self.NUM_bin
    state[ "FOM_bin" ] =  self.FOM_bin
    state[ "HiRes_bin" ] =  self.HiRes_bin
    state[ "LoRes_bin" ] =  self.LoRes_bin
    return state
    
    
def BinStats_setstate(self, state):
    
    assert "NUM_bin" in state
    assert "FOM_bin" in state
    assert "HiRes_bin" in state
    assert "LoRes_bin" in state
    self.NUM_bin = state[ "NUM_bin" ]
    self.FOM_bin = state[ "FOM_bin" ]
    self.HiRes_bin = state[ "HiRes_bin" ]
    self.LoRes_bin = state[ "LoRes_bin" ]
        
def HandEP_getstate(self):
    
    state = SpaceGroup_getstate( self )
    state.update(
        {
        "selected": self.selected,
        "log_likelihood": self.log_likelihood,
        "acentStats": self.acentStats,
        "centStats": self.centStats,
        "allStats": self.allStats,
        "FWT": self.FWT,
        "PHWT": self.PHWT,
        "PHIB": self.PHIB,
        "FOM": self.FOM,
        "FPFOM": self.FPFOM,
        "HL": self.HL,
        "atoms": self.atoms,
        "atoms_extra": self.atoms_extra,
        "PDBfile": self.PDBfile,
        "MTZfile": self.MTZfile,
        "SOLfile": self.SOLfile,
        "AtomFp": self.AtomFp,
        "AtomFdp": self.AtomFdp,
        "t2atomtype": self.t2atomtype,
        }
       )
    return state
    
    
def HandEP_setstate(self, state):
    
    SpaceGroup_setstate( self, state )
    assert "selected" in state
    assert "log_likelihood" in state
    assert "acentStats" in state
    assert "centStats" in state
    assert "allStats" in state
    assert "FWT" in state
    assert "PHWT" in state
    assert "PHIB" in state
    assert "FOM" in state
    assert "FPFOM" in state
    assert "HL" in state
    assert "atoms" in state
    assert "atoms_extra" in state
    assert "PDBfile" in state
    assert "MTZfile" in state
    assert "SOLfile" in state
    self.selected = state[ "selected" ]
    self.log_likelihood = state[ "log_likelihood" ]
    self.acentStats = state[ "acentStats" ]
    self.centStats = state[ "centStats" ]
    self.allStats = state[ "allStats" ]
    self.FWT = state[ "FWT" ]
    self.PHWT = state[ "PHWT" ]
    self.PHIB = state[ "PHIB" ]
    self.FOM = state[ "FOM" ]
    self.FPFOM = state[ "FPFOM" ]
    self.HL = state[ "HL" ]
    self.atoms = state[ "atoms" ]
    self.atoms_extra = state[ "atoms_extra" ]
    self.PDBfile = state[ "PDBfile" ]
    self.MTZfile = state[ "MTZfile" ]
    self.SOLfile = state[ "SOLfile" ]
    self.AtomFp = state[ "AtomFp" ]
    self.AtomFdp = state[ "AtomFdp" ]
    self.t2atomtype = state[ "t2atomtype" ]
    
    
def ResultEP_getstate(self):
    
    d = Output_getstate( self )
    d.update( UnitCell_getstate( self ) )
    d.update(
        {
          "MILLER": self.MILLER,
          "second_hand": self.second_hand,
          "hand1": self.getHand( False ),
          "hand2": self.getHand( True ),
        }
        )
    
    return d


def ResultEP_setstate(self, state):
    
    assert "hand1" in state and "hand2" in state
    Output_setstate( self, state )
    UnitCell_setstate( self, state )
    self.MILLER = state[ "MILLER" ]
    self.second_hand = state[ "second_hand" ]
    self.setHand( state[ "hand1" ], False )
    self.setHand( state[ "hand2" ], True )

    
GETINITARGS_FOR = {
    phaser.mr_rlist: mr_rlist_getinitargs,
    phaser.mr_ndim: mr_ndim_getinitargs,
    phaser.mr_set: mr_set_getinitargs,
    phaser.mr_solution: mr_solution_getinitargs,
    phaser.MapCoefs: MapCoefs_getinitargs,
    phaser.data_refl: data_refl_getinitargs,
    phaser.DataA: DataA_getinitargs,
    phaser.ResultMR: ResultMR_getinitargs,
    phaser.ResultMR_RF: ResultMR_RF_getinitargs,
    phaser.ResultMR_TF: ResultMR_TF_getinitargs,
    phaser.ResultANO: ResultANO_getinitargs,
    }

GET_SET_STATE_FOR = {
    phaser.Output: ( Output_getstate, Output_setstate ),
    phaser.UnitCell: ( UnitCell_getstate, UnitCell_setstate ),
    phaser.SpaceGroup: ( SpaceGroup_getstate, SpaceGroup_setstate ),
    phaser.ResultMR: ( ResultMR_getstate, ResultMR_setstate ),
    phaser.ResultMR_RF: ( ResultMR_RF_getstate, ResultMR_RF_setstate ),
    phaser.ResultMR_TF: ( ResultMR_TF_getstate, ResultMR_TF_setstate ),
    phaser.ResultANO: ( ResultANO_getstate, ResultANO_setstate ),
    phaser.BinStats: ( BinStats_getstate, BinStats_setstate ),
    phaser.HandEP: ( HandEP_getstate, HandEP_setstate ),
    phaser.ResultEP: ( ResultEP_getstate, ResultEP_setstate ),
    phaser.scatterer_extra: ( scatterer_extra_getstate, scatterer_extra_setstate ),
    }
    
    
def enable():
    
    for ( phaser_object, getinitargs_method ) in GETINITARGS_FOR.items():
        phaser_object.__getinitargs__ = getinitargs_method
        
    for ( phaser_object, ( getstate_method, setstate_method ) ) in GET_SET_STATE_FOR.items():
        phaser_object.__getstate__ = getstate_method
        phaser_object.__setstate__ = setstate_method