You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ''' import scipy.fftpack from DDFacet.ToolsDir import Gaussian import numpy as np from DDFacet.Other import ClassTimeIt from DDFacet.Other import ModColor from scipy.interpolate import interp1d as interp from DDFacet.ToolsDir import ModToolBox from DDFacet.Array import NpShared from DDFacet.Other import logger log = logger.getLogger("WTerm") # ,disable=True) from DDFacet.ToolsDir import ModTaper from DDFacet.ToolsDir import ModFitPoly2D from DDFacet.ToolsDir import ModFFTW # np.seterr(all='raise') # import warnings # warnings.filterwarnings('error') F2 = scipy.fftpack.fft2 iF2 = scipy.fftpack.ifft2 Fs = scipy.fftpack.fftshift iFs = scipy.fftpack.ifftshift
from DDFacet.Other import logger from DDFacet.Other import ClassTimeIt from DDFacet.Other import ModColor from DDFacet.Other.progressbar import ProgressBar from DDFacet.Data.ClassStokes import ClassStokes from DDFacet.Data.PointingProvider import PointingProvider from DDFacet.Data.ClassMS import ClassMS from astropy import wcs as pywcs from pyrap.measures import measures from pyrap.quanta import quantity from functools import reduce log=logger.getLogger("ClassMontblancMachine") DEBUG = False class ClassMontblancMachine(object): def __init__(self, GD, npix, cell_size_rad, MS, pointing_sols): shndlrs = filter(lambda x: isinstance(x, logging.StreamHandler), montblanc.log.handlers) montblanc.log.propagate = False log_levels = {"NOTSET": logging.NOTSET, "DEBUG": logging.DEBUG, "INFO": logging.INFO, "WARNING": logging.WARNING, "ERROR": logging.ERROR, "CRITICAL": logging.CRITICAL} for s in shndlrs:
of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ''' import numpy as np from DDFacet.Other import logger from DDFacet.Other import ClassTimeIt from DDFacet.Other import ModColor log=logger.getLogger("ClassModelMachineSSD") from DDFacet.Array import NpParallel from DDFacet.Array import ModLinAlg from DDFacet.ToolsDir import ModFFTW from DDFacet.ToolsDir import ModToolBox from DDFacet.Other import ClassTimeIt from DDFacet.Other import MyPickle from DDFacet.Other import reformat from DDFacet.Imager import ClassFrequencyMachine from DDFacet.ToolsDir.GiveEdges import GiveEdges from DDFacet.Imager import ClassModelMachine as ClassModelMachinebase from DDFacet.ToolsDir import ModFFTW import scipy.ndimage from SkyModel.Sky import ModRegFile from pyrap.images import image from SkyModel.Sky import ClassSM
You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ''' from __future__ import absolute_import from __future__ import division from __future__ import print_function from DDFacet.compatibility import range import os import numpy as np from DDFacet.Other import logger from DDFacet.Other import ModColor log = logger.getLogger("ClassImageDeconvMachine") from DDFacet.Array import NpParallel from DDFacet.Array import NpShared from DDFacet.ToolsDir import ModFFTW from DDFacet.ToolsDir import ModToolBox from DDFacet.Other import ClassTimeIt from pyrap.images import image from DDFacet.Imager.ClassPSFServer import ClassPSFServer from DDFacet.Other.progressbar import ProgressBar from DDFacet.Imager import ClassGainMachine from DDFacet.Other import MyPickle import multiprocessing import time #from DDFacet.Imager.MORESANE.ClassMoresaneSingleSlice import ClassMoresaneSingleSlice ##from DDFacet.Imager.MUFFIN.easy_muffin.easy_muffin_py.deconv3d import EasyMuffin from easy_muffin_py.deconv3d import EasyMuffin
GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ''' from __future__ import absolute_import from __future__ import division from __future__ import print_function from DDFacet.compatibility import range import time as timemod from DDFacet.Other import logger log = logger.getLogger("ClassTimeIt") DoLog = False class ClassTimeIt(): def __init__(self, name=""): self.t0 = timemod.time() self.IsEnable = True if name == "": self.name = name else: self.name = name+": " self.IsEnableIncr = False self.Counter = ""
GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ''' from __future__ import absolute_import from __future__ import division from __future__ import print_function from DDFacet.compatibility import range import numpy as np from DDFacet.Other import logger log = logger.getLogger("ClassJones") from DDFacet.Other import reformat from DDFacet.Array import NpShared import os from DDFacet.Array import ModLinAlg from DDFacet.Other.progressbar import ProgressBar from DDFacet.Data import ClassLOFARBeam from DDFacet.Data import ClassFITSBeam # import ClassSmoothJones is not used anywhere, should be able to remove it import tables from scipy.interpolate import interp1d def _parse_solsfile(SolsFile): """Parses the input SolsFile in order to use an input h5parm file to apply solutions on-the-fly. The solution directions dictate the on-the-fly facet layout.
from pyrap.images import image import numpy as np from DDFacet.Imager import ClassCasaImage #from DDFacet.Imager.ModModelMachine import GiveModelMachine from DDFacet.Imager.ModModelMachine import ClassModModelMachine from DDFacet.Other import logger from DDFacet.ToolsDir import ModFFTW from DDFacet.Other import AsyncProcessPool from DDFacet.Other.AsyncProcessPool import APP, WorkerProcessError from DDFacet.Other import Multiprocessing from DDFacet.Other import logger from DDFacet.Other import MyPickle from DDFacet.ToolsDir.rad2hmsdms import rad2hmsdms log=logger.getLogger("ClassRestoreMachine") import scipy.signal import scipy.stats import multiprocessing NCPU_default=str(int(0.75*multiprocessing.cpu_count())) def read_options(): desc="""DDFacet """ opt = optparse.OptionParser(usage='Usage: %prog <options>',version='%prog version 1.0',description=desc) group = optparse.OptionGroup(opt, "* Data selection options") group.add_option('--BaseImageName',help='') group.add_option('--ResidualImage',help='',type="str",default="")
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ''' from __future__ import absolute_import from __future__ import division from __future__ import print_function from DDFacet.compatibility import range import numpy as np import warnings warnings.simplefilter('ignore', np.RankWarning) from scipy.optimize import curve_fit, fmin_l_bfgs_b from DDFacet.Other import logger from DDFacet.Imager.ClassScaleMachine import Store log = logger.getLogger("ClassFreqMachine") class ClassFrequencyMachine(object): """ Interface to fit frequency axis in model image. All fitting is currently based on some polynomial model in normalised frequencies (v/v_0). For the alpha map the fit happens in log space. Initialisation: ModelCube = A cube containing the model image with shape [NChannel,NPol,Npix,Npix] Freqs = The gridding frequencies Freqsp = The degridding frequencies ref_freq = The reference frequency Methods: getFitMask : Creates a mask to fit models to setDesMat : Creates a design matrix in either log or normal space FitAlphaMap : Fits an alpha map to pixels in the model image above a user specified threshold
import queue else: import Queue import multiprocessing import numpy as np import glob import re from DDFacet.Other import logger from DDFacet.Other import ClassTimeIt from DDFacet.Other import ModColor from DDFacet.Other.progressbar import ProgressBar from DDFacet.Array import NpShared from DDFacet.Array import shared_dict log = logger.getLogger("Multiprocessing") #MyLogger.setSilent("Multiprocessing") # store PID here, so that it corresponds to the PID of the parent thread (when we fork off child processes) _pid = os.getpid() def getShmPrefix(): """Returns prefix used for shared memory arrays. ddf.PID is the convention""" return "ddf.%d" % _pid # init SharedDict with the same base name shared_dict.SharedDict.setBaseName(getShmPrefix()) def getShmName(name, **kw): """ Forms up a name for a shm-backed shared element. This takes the form of "ddf.PID.", where PID is the
along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ''' from __future__ import absolute_import from __future__ import division from __future__ import print_function from DDFacet.compatibility import range import re import numpy as np from DDFacet.Other import logger log = logger.getLogger("ClassStokes") ''' Enumeration of stokes and correlations used in MS2.0 - as per Stokes.h in casacore, the rest are left unimplemented: These are useful when working with visibility data (https://casa.nrao.edu/Memos/229.html#SECTION000613000000000000000) ''' StokesTypes = { 'I': 1, 'Q': 2, 'U': 3, 'V': 4, 'RR': 5, 'RL': 6, 'LR': 7, 'LL': 8, 'XX': 9,
from pyrap.images import image from SkyModel.Sky import ClassSM import optparse import numpy as np import glob import os from SkyModel.Other import reformat SaveFile="last_MyCasapy2BBS.obj" import pickle import scipy.ndimage from SkyModel.Tools import ModFFTW from SkyModel.PSourceExtract import ClassIslands from SkyModel.Other.ClassCasaImage import PutDataInNewImage import scipy.special from DDFacet.Other import logger log=logger.getLogger("MakeMask") from SkyModel.Other.progressbar import ProgressBar import collections from SkyModel.Other.MyHist import MyCumulHist from SkyModel.PSourceExtract import Gaussian from SkyModel.Sky import ModRegFile from DDFacet.ToolsDir import ModFFTW import DDFacet.Imager.SSD.ClassIslandDistanceMachine from DDFacet.ToolsDir.rad2hmsdms import rad2hmsdms from DDFacet.Other import MyPickle from DDFacet.ToolsDir import ModCoord import DDFacet.Other.MyPickle from matplotlib.path import Path def read_options(): desc=""" [email protected]"""
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. """ from __future__ import absolute_import from __future__ import division from __future__ import print_function import numpy as np from pyrap.tables import table from killMS.Other.rad2hmsdms import rad2hmsdms from killMS.Other import ModColor from killMS.Other import reformat import os import pyrap.quanta as qa import pyrap.measures as pm import ephem from DDFacet.Other import logger log = logger.getLogger("ClassMS") from killMS.Other import ClassTimeIt from DDFacet.Other.progressbar import ProgressBar import DDFacet.ToolsDir.ModRotate #from DDFacet.Other.PrintList import ListToStr class ClassMS(): def __init__(self, MSname, Col="DATA", zero_flag=True, ReOrder=False, EqualizeFlag=False, DoPrint=True, DoReadData=True,
if six.PY3: import DDFacet.cbuild.Gridder._pyGridder3x as _pyGridder else: import DDFacet.cbuild.Gridder._pyGridder27 as _pyGridder ##########################################################" import numpy as np import os from DDFacet.Imager import ModCF from DDFacet.ToolsDir.ModToolBox import EstimateNpix from DDFacet.ToolsDir import ModFFTW from DDFacet.Parset import ReadCFG from DDFacet.Other import ClassTimeIt from DDFacet.Data import ClassVisServer from DDFacet.Other import logger log = logger.getLogger("ClassDDEGridMachine") def testGrid(): import pylab # Parset=ReadCFG.Parset("%s/Parset/DefaultParset.cfg"%os.environ["DDFACET_DIR"]) Parset = ReadCFG.Parset("%s/DDFacet/Parset/DefaultParset.cfg" % os.environ["DDFACET_DIR"]) DC = Parset.DicoPars # 19 (-0.01442078294460315, 0.014406238534169863) 2025 3465 -10.0 #(array([0]), array([0]), array([1015]), array([1201])) #(array([0]), array([0]), array([1050]), array([1398])) # 17 (-0.014391694123736577, 0.01437714971330329) 2025 3465 -10.0 #(array([0]), array([0]), array([1030]), array([1303]))
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ''' import optparse from DDFacet.Array import NpShared from DDFacet.Other import logger log = logger.getLogger("ClearSHM") from DDFacet.cbuild.Gridder import _pyGridderSmearPols as _pyGridderSmear import glob import os import shutil from DDFacet.Other import Multiprocessing def read_options(): desc = """CohJones Questions and suggestions: [email protected]""" opt = optparse.OptionParser(usage='Usage: %prog <options>', version='%prog version 1.0', description=desc)
import numpy as np import Polygon from scipy.spatial import Voronoi from deap import algorithms import DeapAlgo as algorithms from deap import base from deap import creator from deap import tools #import pylab from scipy.spatial import Voronoi import ModVoronoi from DDFacet.Other import logger log = logger.getLogger("ClusterDEAP") from DDFacet.Other import ClassTimeIt #from scoop import futures import multiprocessing import scipy.stats import Polygon Theta = np.linspace(-np.pi, np.pi / 2, 21) def hasStraightEdge(P): p = np.array(P)[0] dx = ((p[1:, 0] - p[:-1, 0]) == 0) dy = ((p[1:, 1] - p[:-1, 1]) == 0) if np.count_nonzero(dx) or np.count_nonzero(dy): return True return False
from __future__ import absolute_import from __future__ import division from __future__ import print_function from DDFacet.compatibility import range import collections import random import numpy as np from DDFacet.Other import ClassTimeIt from DDFacet.Other import logger from deap import tools from mpl_toolkits.axes_grid1 import make_axes_locatable log = logger.getLogger("ClassArrayMethodGA") from DDFacet.Imager.SSD.ClassParamMachine import ClassParamMachine from DDFacet.ToolsDir.GeneDist import ClassDistMachine class ClassArrayMethodGA(): def __init__(self, Dirty, PSF, ListPixParms, ListPixData, FreqsInfo, GD=None, PixVariance=1.e-2, IslandBestIndiv=None,
from __future__ import division from __future__ import print_function from DDFacet.compatibility import range import os, os.path, subprocess import six if six.PY3: import pickle as cPickle else: import cPickle import collections from DDFacet.Other import logger, ModColor log = logger.getLogger("CacheManager") class CacheManager(object): """ # CacheManager This is a simple disk-based cache management class. Usage is as follows: cache = CacheManager("/cache/directory") This creates a cache based on the specified path. Directory is created if it doesn't exist. If you create CacheManager with reset=True, the contents of the directory are deleted. Typically, you would use the cache in the following pattern:
def main(OP=None, messages=[]): if OP is None: OP = MyPickle.Load(SaveFile) print("Using settings from %s, then command line."%SaveFile) DicoConfig = OP.DicoConfig ImageName = DicoConfig["Output"]["Name"] if not ImageName: raise Exceptions.UserInputError("--Output-Name not specified, can't continue.") if not DicoConfig["Data"]["MS"]: raise Exceptions.UserInputError("--Data-MS not specified, can't continue.") # create directory if it exists dirname = os.path.dirname(ImageName) if not os.path.exists(dirname) and not dirname == "": os.mkdir(dirname) # setup logging logger.logToFile(ImageName + ".log", append=DicoConfig["Log"]["Append"]) global log log = logger.getLogger("DDFacet") # disable colors and progressbars if requested ModColor.silent = SkyModel.Other.ModColor.silent = \ progressbar.ProgressBar.silent = \ DicoConfig["Log"]["Boring"] if messages: if not DicoConfig["Log"]["Boring"]: #os.system('clear') logo.print_logo() for msg in messages: print(msg, file=log) print("Checking system configuration:", file=log) # check for SHM size ram_size = os.sysconf('SC_PAGE_SIZE') * os.sysconf('SC_PHYS_PAGES') shm_stats = os.statvfs('/dev/shm') shm_size = shm_stats.f_bsize * shm_stats.f_blocks shm_relsize = shm_size / float(ram_size) shm_avail = shm_stats.f_bsize * shm_stats.f_bavail / float(ram_size) if shm_relsize < 0.6: print(ModColor.Str("""WARNING: max shared memory size is only {:.0%} of total RAM size. This can cause problems for large imaging jobs. A setting of 90% is recommended for DDFacet and killMS. If your processes keep failing with SIGBUS or "bus error" messages, it is most likely for this reason. You can change the memory size by running $ sudo mount -o remount,size=90% /dev/shm To make the change permanent, edit /etc/defaults/tmps, and add a line saying "SHM_SIZE=90%". """.format(shm_relsize)), file=log) else: print(" Max shared memory size is {:.0%} of total RAM size; {:.0%} currently available".format(shm_relsize, shm_avail), file=log) try: output = subprocess.check_output(["/sbin/sysctl", "vm.max_map_count"],universal_newlines=True) except Exception: print(ModColor.Str("""WARNING: /sbin/sysctl vm.max_map_count failed. Unable to check this setting."""), file=log) max_map_count = None else: max_map_count = int(output.strip().rsplit(" ", 1)[-1]) if max_map_count is not None: if max_map_count < 500000: print(ModColor.Str("""WARNING: sysctl vm.max_map_count = {}. This may be too little for large DDFacet and killMS jobs. If you get strange "file exists" errors on /dev/shm, them try to bribe, beg or threaten your friendly local sysadmin into setting vm.max_map_count=1000000 in /etc/sysctl.conf. """.format(max_map_count)), file=log) else: print(" sysctl vm.max_map_count = {}".format(max_map_count), file=log) # check for memory lock limits import resource msoft, mhard = resource.getrlimit(resource.RLIMIT_MEMLOCK) if msoft >=0 or mhard >=0: print(ModColor.Str("""WARNING: your system has a limit on memory locks configured. This may possibly slow down DDFacet performance. You can try removing the limit by running $ ulimit -l unlimited If this gives an "operation not permitted" error, you can try to bribe, beg or threaten your friendly local sysadmin into doing # echo "* - memlock unlimited" >> /etc/security/limits.conf """), file=log) if DicoConfig["Debug"]["Pdb"] == "always": print("--Debug-Pdb=always: unexpected errors will be dropped into pdb", file=log) Exceptions.enable_pdb_on_error(ModColor.Str("DDFacet has encountered an unexpected error. Dropping you into pdb for a post-mortem.\n" + "(This is because you're running with --Debug-Pdb set to 'always'.)")) elif DicoConfig["Debug"]["Pdb"] == "auto" and not DicoConfig["Log"]["Boring"]: print("--Debug-Pdb=auto and not --Log-Boring: unexpected errors will be dropped into pdb", file=log) Exceptions.enable_pdb_on_error(ModColor.Str("DDFacet has encountered an unexpected error. Dropping you into pdb for a post-mortem.\n" + "(This is because you're running with --Debug-Pdb set to 'auto' and --Log-Boring is off.)")) # print current options OP.Print(dest=log) # enable memory logging logger.enableMemoryLogging(DicoConfig["Log"]["Memory"]) # get rid of old shm arrays from previous runs Multiprocessing.cleanupStaleShm() # initialize random seed from config if set, or else from system time if DicoConfig["Misc"]["RandomSeed"] is not None: DicoConfig["Misc"]["RandomSeed"]=int(DicoConfig["Misc"]["RandomSeed"]) print("random seed=%d (explicit)" % DicoConfig["Misc"]["RandomSeed"], file=log) else: DicoConfig["Misc"]["RandomSeed"] = int(time.time()) print("random seed=%d (automatic)" % DicoConfig["Misc"]["RandomSeed"], file=log) np.random.seed(DicoConfig["Misc"]["RandomSeed"]) # init NCPU for different bits of parallelism ncpu = int(DicoConfig["Parallel"]["NCPU"] or psutil.cpu_count()) DicoConfig["Parallel"]["NCPU"]=ncpu _pyArrays.pySetOMPNumThreads(ncpu) NpParallel.NCPU_global = ModFFTW.NCPU_global = ncpu numexpr.set_num_threads(ncpu) print("using up to %d CPUs for parallelism" % ncpu, file=log) # write parset OP.ToParset("%s.parset"%ImageName) Mode = DicoConfig["Output"]["Mode"] # init semaphores, as they're needed for weight calculation too ClassFacetMachine.ClassFacetMachine.setup_semaphores(DicoConfig) # data machine initialized for all cases except PSF-only mode # psf machine initialized for all cases except Predict-only mode Imager = ClassDeconvMachine.ClassImagerDeconv(GD=DicoConfig, BaseName=ImageName, predict_only=(Mode == "Predict" or Mode == "Subtract"), data=(Mode != "PSF"), psf=(Mode != "Predict" and Mode != "Dirty" and Mode != "Subtract"), readcol=(Mode != "Predict" and Mode != "PSF"), deconvolve=("Clean" in Mode)) Imager.Init() # Imager.testDegrid() # stop if "Predict" in Mode or "Subtract" in Mode: Imager.GivePredict() if "Clean" in Mode: Imager.main() elif "Dirty" in Mode: sparsify = DicoConfig["Comp"]["Sparsification"] if sparsify and isinstance(sparsify, list): sparsify = sparsify[0] Imager.GiveDirty(psf="PSF" in Mode, sparsify=sparsify) elif "PSF" in Mode: sparsify = DicoConfig["Comp"]["Sparsification"] if sparsify and isinstance(sparsify, list): sparsify = sparsify[0] Imager.MakePSF(sparsify=sparsify) elif "RestoreAndShift" == Mode: Imager.RestoreAndShift()
along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ''' from __future__ import absolute_import from __future__ import division from __future__ import print_function from DDFacet.compatibility import range from DDFacet.Imager import ClassModelMachine from DDFacet.Imager import ClassGainMachine from DDFacet.Other import MyPickle from DDFacet.Other import logger from DDFacet.Other import ModColor log=logger.getLogger("GiveModelMachine") class ClassModModelMachine(): """ This is the factory class for ModelMachine. Basically give it a dictionary containing the components of a model image and it instantiates and returns a copy of the correct ModelMachine. Each pickled dictionary should contain a field labelling which deconvolution algorithm it corresponds to. """ def __init__(self,GD=None): """ Input: GD = Global dictionary """ self.GD = GD self.SSDMM = None self.MSMFMM = None
along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. """ #!/usr/bin/env python from __future__ import absolute_import from __future__ import division from __future__ import print_function import optparse import sys from killMS.Other import MyPickle from killMS.Other import logo from killMS.Other import ModColor from DDFacet.Other import logger import os log = logger.getLogger("killMS") logger.itsLog.logger.setLevel(logger.logging.CRITICAL) sys.path = [ name for name in sys.path if not (("pyrap" in name) & ("/usr/local/lib/" in name)) ] # test #import numpy #print numpy.__file__ #import pyrap #print pyrap.__file__ #stop
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. """ import numpy as np from killMS.Array import ModLinAlg from DDFacet.Other import logger log = logger.getLogger("ClassJonesDomains") class ClassJonesDomains(): def __init__(self): pass def GiveFreqDomains(self, ChanFreqs, ChanWidth, NChanJones=0): if NChanJones == 0: NChanJones = ChanFreqs.size ChanEdges = np.linspace(ChanFreqs.min() - ChanWidth / 2., ChanFreqs.max() + ChanWidth / 2., NChanJones + 1) FreqDomains = [[ChanEdges[iF], ChanEdges[iF + 1]] for iF in range(NChanJones)] return np.array(FreqDomains)
You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ''' from __future__ import absolute_import from __future__ import division from __future__ import print_function from DDFacet.compatibility import range import itertools import numpy as np from DDFacet.Other import logger from DDFacet.Other import ModColor log=logger.getLogger("ClassModelMachineHogbom") from DDFacet.ToolsDir import ModFFTW from DDFacet.Other import MyPickle from DDFacet.Other import reformat from DDFacet.Imager import ClassModelMachine as ClassModelMachinebase from DDFacet.Imager import ClassFrequencyMachine import scipy.ndimage import os from pyrap.images import image # don't remove - part of KMS requirements from SkyModel.Sky import ClassSM # don't remove - part of KMS requirements class ClassModelMachine(ClassModelMachinebase.ClassModelMachine): def __init__(self,*args,**kwargs): ClassModelMachinebase.ClassModelMachine.__init__(self, *args, **kwargs) self.DicoSMStacked={} self.DicoSMStacked["Type"]="Hogbom"
from __future__ import absolute_import from __future__ import division from __future__ import print_function from DDFacet.compatibility import range import os import os.path from pyrap.images import image import DDFacet.Data.ClassStokes as ClassStokes import numpy as np from DDFacet.Other import logger log = logger.getLogger("ClassCasaImage") from astropy.io import fits from astropy.wcs import WCS from DDFacet.report_version import report_version def FileToArray(FileName, CorrT): """ Read a FITS FileName file to an array """ hdu = fits.open(FileName) NormImage = hdu[0].data if len(NormImage.shape) == 4: nch, npol, _, _ = NormImage.shape else: nch, nx, ny = NormImage.shape npol = 1
import numpy as np from DDFacet.Imager.MORESANE import ClassImageDeconvMachineMoresane import copy from DDFacet.ToolsDir.GiveEdges import GiveEdges from DDFacet.ToolsDir.GiveEdges import GiveEdgesDissymetric from DDFacet.Imager.ClassPSFServer import ClassPSFServer from DDFacet.Imager.ModModelMachine import ClassModModelMachine import multiprocessing from DDFacet.Other import ClassTimeIt from DDFacet.Other.progressbar import ProgressBar import time from DDFacet.Array import NpShared from DDFacet.Other import logger log = logger.getLogger("ClassInitSSDModel") import traceback from DDFacet.Other import ModColor from ClassConvMachine import ClassConvMachineImages from DDFacet.Imager import ClassMaskMachine SilentModules = [ "ClassPSFServer", "ClassImageDeconvMachine", "GiveModelMachine", "ClassModelMachineMoresane", "ClassModelMachineSSD", "pymoresane.main" ] class ClassInitSSDModelParallel(): def __init__(self, GD, NFreqBands, RefFreq,
from __future__ import absolute_import from __future__ import division from __future__ import print_function from DDFacet.compatibility import range import numpy as np import scipy.signal from DDFacet.Imager.SSD import ClassConvMachine from DDFacet.Other import logger log = logger.getLogger("ClassSmearSM") import multiprocessing from DDFacet.Array import NpShared from DDFacet.Array import ModLinAlg import time from DDFacet.Other.progressbar import ProgressBar class ClassSmearSM(): def __init__(self, MeanResidual, MeanModelImage, PSFServer, DeltaChi2=4., IdSharedMem="", NCPU=6): IdSharedMem += "SmearSM." NpShared.DelAll(IdSharedMem) self.IdSharedMem = IdSharedMem self.NCPU = NCPU self.MeanModelImage = NpShared.ToShared(
from __future__ import absolute_import from __future__ import division from __future__ import print_function import numpy as np import optparse import pickle import numpy as np from DDFacet.Other import logger log = logger.getLogger("DiagBL") from DDFacet.Array import shared_dict from DDFacet.Other.AsyncProcessPool import APP, WorkerProcessError class ClassCovMat(): def __init__(self, **kwargs): for key, value in kwargs.items(): setattr(self, key, value) self.DictName = "DATA" log.print("I am the machine that compute the weights based") log.print(" on the diag(nt x nt)_iAnt:jAnt matrix") def giveWeigthParallel(self): self.DATA = shared_dict.attach(self.DictName) self.na = self.DATA["na"] for A0 in range(0, self.na): for A1 in range(A0 + 1, self.na): APP.runJob("giveWeigthChunk:%d:%d" % (A0, A1), self.giveWeigthChunk, args=(A0, A1, self.DATA.readwrite())) #,serial=True) APP.awaitJobResults("giveWeigthChunk:*", progress="CalcWeight")
from __future__ import division from __future__ import print_function from __future__ import absolute_import from builtins import str from builtins import range from builtins import object from pyrap.tables import table import sys from DDFacet.Other import logger log=logger.getLogger("DynSpecMS") from DDFacet.Array import shared_dict from DDFacet.Other.AsyncProcessPool import APP, WorkerProcessError from DDFacet.Other import Multiprocessing from DDFacet.Other import ModColor from DDFacet.Other.progressbar import ProgressBar import numpy as np from astropy.time import Time from astropy import constants as const import os from killMS.Other import reformat from DDFacet.Other import AsyncProcessPool import glob from astropy.io import fits from astropy.wcs import WCS from DDFacet.ToolsDir.rad2hmsdms import rad2hmsdms import scipy.stats from killMS.Array import ModLinAlg def AngDist(ra0,ra1,dec0,dec1): AC=np.arccos C=np.cos
GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. """ from __future__ import absolute_import from __future__ import division from __future__ import print_function import matplotlib.pyplot as pylab from pyrap.tables import table from killMS.Data import ClassWeighting from DDFacet.Other import logger log = logger.getLogger("ClassVisServer") import numpy as np def test(): MSName = "BOOTES24_SB100-109.2ch8s.ms" BLC = ClassBLCal(MSName) BLC.CalcBLCal() class ClassBLCal(): def __init__(self, MSName): self.MSName = MSName self.Init() def Init(self):
''' from __future__ import absolute_import from __future__ import division from __future__ import print_function from DDFacet.compatibility import range import numpy import os import os.path import sys from DDFacet.Other import logger log = logger.getLogger("ClassFITSBeam") import pyrap.tables import numpy as np dm = pyrap.measures.measures() dq = pyrap.quanta # This a list of the Stokes enums (as defined in casacore header measures/Stokes.h) # These are referenced by the CORR_TYPE column of the MS POLARIZATION subtable. # E.g. 5,6,7,8 corresponds to RR,RL,LR,LL MS_STOKES_ENUMS = [ "Undefined", "I", "Q", "U", "V", "RR", "RL", "LR", "LL", "XX", "XY", "YX", "YY", "RX", "RY", "LX", "LY", "XR", "XL", "YR", "YL", "PP", "PQ", "QP", "QQ", "RCircular", "LCircular", "Linear", "Ptotal", "Plinear", "PFtotal",
import numpy as np F = scipy.fftpack.fft iF = scipy.fftpack.ifft Fs = scipy.fftpack.fftshift iFs = scipy.fftpack.ifftshift import pyfftw import scipy.signal import numpy #import pyfftw import scipy.signal from DDFacet.Other import logger log = logger.getLogger("ModToolBox", disable=True) # def EstimateNpix(Npix,Padding=1): # Npix=int(round(Npix)) # NpixOrig=Npix # if Npix%2!=0: Npix+=1 # Npix=ModToolBox.GiveClosestFastSize(Npix) # NpixOpt=Npix # Npix*=Padding # Npix=int(round(Npix)) # if Npix%2!=0: Npix+=1 # Npix=ModToolBox.GiveClosestFastSize(Npix) # print ModColor.Str("(NpixOrig, NpixOpt, NpixOptPadded): %i --> %i --> %i"%(NpixOrig,NpixOpt,Npix)) # return NpixOpt,Npix