def __init__(self):
        WPSProcess.__init__(
            self,
            identifier="weatherregimes_projection",
            title="Weather Regimes -- Projection of Weather Regimes",
            version="0.9",
            metadata=[
                {
                    "title": "LSCE",
                    "href": "http://www.lsce.ipsl.fr/en/index.php"
                },
                {
                    "title": "Documentation",
                    "href": "http://flyingpigeon.readthedocs.io/en/latest/"
                },
            ],
            abstract=
            "Weather Regimes detection based on trained reference statistics",
            statusSupported=True,
            storeSupported=True)

        self.resource = self.addComplexInput(
            identifier="resource",
            title="Resource",
            abstract="NetCDF File",
            minOccurs=1,
            maxOccurs=1000,
            maxmegabites=5000,
            formats=[{
                "mimeType": "application/x-netcdf"
            }],
        )

        self.Rdat = self.addLiteralInput(
            identifier="Rdat",
            title="R - workspace",
            abstract=
            "R workspace as output from weather regime reference process",
            type=type(''),
            minOccurs=1,
            maxOccurs=1,
            # default=' http://api.gbif.org/v1/occurrence/download/request/0013848-160118175350007.zip'
            # maxmegabites=50,
            # formats=[{"mimeType":"application/zip"}],
        )

        self.dat = self.addLiteralInput(
            identifier="dat",
            title="R - datafile",
            abstract=
            "R datafile as output from weather regime reference process",
            type=type(''),
            minOccurs=1,
            maxOccurs=1,
            # default=' http://api.gbif.org/v1/occurrence/download/request/0013848-160118175350007.zip'
            # maxmegabites=50,
            # formats=[{"mimeType":"application/zip"}],
        )

        self.netCDF = self.addLiteralInput(
            identifier="netCDF",
            title="netCDF reference",
            abstract=
            "netCDF file as output from weather regime reference process",
            type=type(''),
            minOccurs=0,
            maxOccurs=1,
            # default=' http://api.gbif.org/v1/occurrence/download/request/0013848-160118175350007.zip'
            # maxmegabites=50,
            # formats=[{"mimeType":"application/zip"}],
        )

        self.season = self.addLiteralInput(
            identifier="season",
            title="Time region",
            abstract=
            "Select the months to define the time region (all == whole year will be analysed)",
            default="DJF",
            type=type(''),
            minOccurs=1,
            maxOccurs=1,
            allowedValues=_TIMEREGIONS_.keys())

        self.period = self.addLiteralInput(
            identifier="period",
            title="Period for weather regime calculation",
            abstract="Period for analysing the dataset",
            default="19700101-20101231",
            type=type(''),
            minOccurs=1,
            maxOccurs=1,
        )

        self.anualcycle = self.addLiteralInput(
            identifier="anualcycle",
            title="Period for annual cycle calculation",
            abstract="Period for annual cycle calculation",
            default="19700101-19991231",
            type=type(''),
            minOccurs=1,
            maxOccurs=1,
        )

        ####################
        # define the outputs
        ####################

        # self.Routput_graphic = self.addComplexOutput(
        #     identifier="Routput_graphic",
        #     title="Graphics and Tables",
        #     abstract="Weather classification pressure map and frequency table",
        #     formats=[{"mimeType":"image/pdf"}],
        #     asReference=True,
        #     )

        self.output_pca = self.addComplexOutput(
            identifier="output_pca",
            title="PCA",
            abstract="Principal components",
            formats=[{
                "mimeType": "text/plain"
            }],
            asReference=True,
        )

        self.output_classification = self.addComplexOutput(
            identifier="output_classification",
            title="classification",
            abstract="Weather regime classification",
            formats=[{
                "mimeType": "application/octet-stream"
            }],
            asReference=True,
        )

        self.output_frequency = self.addComplexOutput(
            identifier="output_frequency",
            title="Frequency",
            abstract="Weather regime frequency values per year",
            formats=[{
                "mimeType": "text/plain"
            }],
            asReference=True,
        )

        self.output_netcdf = self.addComplexOutput(
            identifier="output_netcdf",
            title="netCDF file",
            abstract=
            "Prepared netCDF file as input for weather regime calculation",
            formats=[{
                "mimeType": "application/x-netcdf"
            }],
            asReference=True,
        )

        self.output_log = self.addComplexOutput(
            identifier="output_log",
            title="Logging information",
            abstract="Collected logs during process run.",
            formats=[{
                "mimeType": "text/plain"
            }],
            asReference=True,
        )
Exemple #2
0
    def __init__(self):
        inputs = [

            # self.BBox = self.addBBoxInput(
            #     identifier="BBox",
            #     title="Bounding Box",
            #     abstract="coordinates to define the region for weather classification ('EPSG:4326')",
            #     minOccurs=1,
            #     maxOccurs=1,
            #     crss=['EPSG:4326']
            #     )

            # Literal Input Data
            # ------------------

            # self.BBox = self.addLiteralInput(
            #     identifier="BBox",
            #     title="Region",
            #     abstract="coordinates to define the region: (minlon,maxlon,minlat,maxlat)",
            #     default='-80,22.5,50,70', #  cdo syntax: 'minlon,maxlon,minlat,maxlat' ;
            #  ocgis syntax (minlon,minlat,maxlon,maxlat)
            #     type=type(''),
            #     minOccurs=1,
            #     maxOccurs=1,
            #     )
            LiteralInput(
                "season",
                "Time region",
                abstract=
                "Select the months to define the time region (all == whole year will be analysed)",
                default="DJF",
                data_type='string',
                min_occurs=1,
                max_occurs=1,
                allowed_values=_TIMEREGIONS_.keys()),
            LiteralInput(
                'BBox',
                'Bounding Box',
                data_type='string',
                abstract="Enter a bbox: min_lon, max_lon, min_lat, max_lat."
                " min_lon=Western longitude,"
                " max_lon=Eastern longitude,"
                " min_lat=Southern or northern latitude,"
                " max_lat=Northern or southern latitude."
                " For example: -80,50,20,70",
                min_occurs=1,
                max_occurs=1,
                default='-80,50,20,70',
            ),
            LiteralInput(
                "period",
                "Period for weatherregime calculation",
                abstract="Period for analysing the dataset",
                default="19700101-20101231",
                data_type='string',
                min_occurs=1,
                max_occurs=1,
            ),
            LiteralInput(
                "anualcycle",
                "Period for anualcycle calculation",
                abstract="Period for anual cycle calculation",
                default="19700101-19991231",
                data_type='string',
                min_occurs=1,
                max_occurs=1,
            ),
            LiteralInput("reanalyses",
                         "Reanalyses Data",
                         abstract="Choose a reanalyses dataset for comparison",
                         default="NCEP_slp",
                         data_type='string',
                         min_occurs=1,
                         max_occurs=1,
                         allowed_values=_PRESSUREDATA_),
            LiteralInput("method",
                         "Method of annual cycle calculation",
                         abstract="Method of annual cycle calculation",
                         default="ocgis",
                         data_type='string',
                         min_occurs=1,
                         max_occurs=1,
                         allowed_values=['ocgis', 'cdo']),
            LiteralInput("sseas",
                         "Serial or multiprocessing for annual cycle",
                         abstract="Serial or multiprocessing for annual cycle",
                         default="multi",
                         data_type='string',
                         min_occurs=1,
                         max_occurs=1,
                         allowed_values=['serial', 'multi']),
            LiteralInput("kappa",
                         "Nr of Weather regimes",
                         abstract="Set the number of clusters to be detected",
                         default='4',
                         data_type='integer',
                         min_occurs=1,
                         max_occurs=1,
                         allowed_values=range(2, 11)),
        ]

        outputs = [
            ComplexOutput(
                "Routput_graphic",
                "Weather Regime Pressure map",
                abstract="Weather Classification",
                supported_formats=[Format('image/pdf')],
                as_reference=True,
            ),
            ComplexOutput(
                "output_pca",
                "R - datafile",
                abstract="Principal components (PCA)",
                supported_formats=[Format('text/plain')],
                as_reference=True,
            ),
            ComplexOutput(
                "output_classification",
                "R - workspace",
                abstract="Weather regime classification",
                supported_formats=[Format("application/octet-stream")],
                as_reference=True,
            ),
            ComplexOutput(
                'output_netcdf',
                'Subsets for one dataset',
                abstract=
                "Prepared netCDF file as input for weatherregime calculation",
                as_reference=True,
                supported_formats=[Format('application/x-netcdf')]),
            ComplexOutput('output_log',
                          'Logging information',
                          abstract="Collected logs during process run.",
                          as_reference=True,
                          supported_formats=[Format('text/plain')]),
        ]

        super(WeatherregimesreanalyseProcess, self).__init__(
            self._handler,
            identifier="weatherregimes_reanalyse",
            title="Weather Regimes (based on reanalyses data)",
            abstract=
            'k-mean cluster analyse of the pressure patterns. Clusters are equivalent to weather regimes',
            version="0.10",
            metadata=[
                Metadata('LSCE', 'http://www.lsce.ipsl.fr/en/index.php'),
                Metadata('Doc',
                         'http://flyingpigeon.readthedocs.io/en/latest/'),
            ],
            inputs=inputs,
            outputs=outputs,
            status_supported=True,
            store_supported=True,
        )
    def __init__(self):
        WPSProcess.__init__(
            self,
            identifier="weatherregimes_reanalyse",
            title="Weather Regimes -- Reanalyses data",
            version="0.9",
            metadata=[
                {
                    "title": "LSCE",
                    "href": "http://www.lsce.ipsl.fr/en/index.php"
                },
                {
                    "title": "Documentation",
                    "href": "http://flyingpigeon.readthedocs.io/en/latest/"
                },
            ],
            abstract=
            "Weather Regimes based on pressure patterns, fetching selected Realayses Datasets",
            statusSupported=True,
            storeSupported=True)

        # Literal Input Data
        # ------------------
        self.BBox = self.addBBoxInput(
            identifier="BBox",
            title="Bounding Box",
            abstract=
            "coordinates to define the region for weather classification ('EPSG:4326')",
            minOccurs=1,
            maxOccurs=1,
            crss=['EPSG:4326'])

        # self.BBox = self.addLiteralInput(
        #     identifier="BBox",
        #     title="Region",
        #     abstract="coordinates to define the region: (minlon,maxlon,minlat,maxlat)",
        #     default='-80,22.5,50,70', #  cdo syntax: 'minlon,maxlon,minlat,maxlat' ;\
        #  ocgis syntax (minlon,minlat,maxlon,maxlat)
        #     type=type(''),
        #     minOccurs=1,
        #     maxOccurs=1,
        #     )

        self.season = self.addLiteralInput(
            identifier="season",
            title="Time region",
            abstract=
            "Select the months to define the time region (all == whole year will be analysed)",
            default="DJF",
            type=type(''),
            minOccurs=1,
            maxOccurs=1,
            allowedValues=_TIMEREGIONS_.keys())

        self.period = self.addLiteralInput(
            identifier="period",
            title="Period for weatherregime calculation",
            abstract="Period for analysing the dataset",
            default="19700101-20101231",
            type=type(''),
            minOccurs=1,
            maxOccurs=1,
        )

        self.anualcycle = self.addLiteralInput(
            identifier="anualcycle",
            title="Period for anualcycle calculation",
            abstract="Period for anual cycle calculation",
            default="19700101-19991231",
            type=type(''),
            minOccurs=1,
            maxOccurs=1,
        )

        self.reanalyses = self.addLiteralInput(
            identifier="reanalyses",
            title="Reanalyses Data",
            abstract="Choose a reanalyses dataset for comparison",
            default="NCEP_slp",
            type=type(''),
            minOccurs=1,
            maxOccurs=1,
            allowedValues=_PRESSUREDATA_)

        self.kappa = self.addLiteralInput(
            identifier="kappa",
            title="Nr of Weather regimes",
            abstract="Set the number of clusters to be detected",
            default=4,
            type=type(1),
            minOccurs=1,
            maxOccurs=1,
            allowedValues=range(2, 11))

        ######################
        # define the outputs
        ######################

        self.Routput_graphic = self.addComplexOutput(
            identifier="Routput_graphic",
            title="Weather Regime Pressure map",
            abstract="Weather Classification",
            formats=[{
                "mimeType": "image/pdf"
            }],
            asReference=True,
        )

        self.output_pca = self.addComplexOutput(
            identifier="output_pca",
            title="R - datafile",
            abstract="Principal components (PCA)",
            formats=[{
                "mimeType": "text/plain"
            }],
            asReference=True,
        )

        self.output_classification = self.addComplexOutput(
            identifier="output_classification",
            title="R - workspace",
            abstract="Weather regime classification",
            formats=[{
                "mimeType": "application/octet-stream"
            }],
            asReference=True,
        )

        self.output_netcdf = self.addComplexOutput(
            identifier="output_netcdf",
            title="netCDF reference",
            abstract=
            "Prepared netCDF file as input for weatherregime calculation",
            formats=[{
                "mimeType": "application/x-netcdf"
            }],
            asReference=True,
        )

        self.output_log = self.addComplexOutput(
            identifier="output_log",
            title="Logging information",
            abstract="Collected logs during process run.",
            formats=[{
                "mimeType": "text/plain"
            }],
            asReference=True,
        )
    def __init__(self):
        WPSProcess.__init__(
            self,
            identifier = "weatherregimes_model",
            title = "Weather Regimes -- Climate model data",
            version = "0.9",
            metadata=[
                {"title": "LSCE", "href": "http://www.lsce.ipsl.fr/en/index.php"},
                {"title": "Documentation", "href": "http://flyingpigeon.readthedocs.io/en/latest/"},
                ],
            abstract="Weather Regimes based on pressure patterns, fetching selected Realayses Datasets",
            statusSupported=True,
            storeSupported=True
            )

        self.resource = self.addComplexInput(
            identifier="resource",
            title="Resource",
            abstract="NetCDF File",
            minOccurs=1,
            maxOccurs=1000,
            maxmegabites=5000,
            formats=[{"mimeType":"application/x-netcdf"}],
            )

        # Literal Input Data
        # ------------------
        self.BBox = self.addBBoxInput(
            identifier="BBox",
            title="Bounding Box",
            abstract="coordinates to define the region for weather classification",
            minOccurs=1,
            maxOccurs=1,
            crss=['EPSG:4326']
            )

        # self.BBox = self.addLiteralInput(
        #     identifier="BBox",
        #     title="Region",
        #     abstract="coordinates to define the region: (minlon,maxlon,minlat,maxlat)",
        #     default='-80,22.5,50,70', #  cdo syntax: 'minlon,maxlon,minlat,maxlat' ; ocgis syntax (minlon,minlat,maxlon,maxlat)
        #     type=type(''),
        #     minOccurs=1,
        #     maxOccurs=1,
        #     )

        self.season = self.addLiteralInput(
            identifier="season",
            title="Time region",
            abstract="Select the months to define the time region (all == whole year will be analysed)",
            default="DJF",
            type=type(''),
            minOccurs=1,
            maxOccurs=1,
            allowedValues= _TIMEREGIONS_.keys() 
            )

        self.period = self.addLiteralInput(
            identifier="period",
            title="Period for weatherregime calculation",
            abstract="Period for analysing the dataset",
            default="19700101-20101231",
            type=type(''),
            minOccurs=1,
            maxOccurs=1,
            )

        self.anualcycle = self.addLiteralInput(
            identifier="anualcycle",
            title="Period for anualcycle calculation",
            abstract="Period for anual cycle calculation",
            default="19700101-19991231",
            type=type(''),
            minOccurs=1,
            maxOccurs=1,
            )

        self.kappa = self.addLiteralInput(
            identifier="kappa",
            title="Nr of Weather regimes",
            abstract="Set the number of clusters to be detected",
            default=4,
            type=type(1),
            minOccurs=1,
            maxOccurs=1,
            allowedValues=range(2,11)
            )
        

        ######################
        ### define the outputs
        ######################

        self.Routput_graphic = self.addComplexOutput(
            identifier="Routput_graphic",
            title="Weather Regime Pressure map",
            abstract="Weather Classification",
            formats=[{"mimeType":"image/pdf"}],
            asReference=True,
            )
        
        self.output_pca = self.addComplexOutput(
            identifier="output_pca",
            title="R - datafile",
            abstract="Principal components (PCA)",
            formats=[{"mimeType":"text/plain"}],
            asReference=True,
            )

        self.output_classification = self.addComplexOutput(
            identifier="output_classification",
            title="R - workspace",
            abstract="Weather regime classification",
            formats=[{"mimeType":"application/octet-stream"}],
            asReference=True,
            )

        self.output_netcdf = self.addComplexOutput(
            identifier="output_netcdf",
            title="netCDF reference",
            abstract="Prepared netCDF file as input for weatherregime calculation",
            formats=[{"mimeType":"application/x-netcdf"}],
            asReference=True,
            )
    def __init__(self):
        WPSProcess.__init__(
            self,
            identifier = "weatherregimes_projection",
            title = "Weather Regimes -- Projection of Weather Regimes",
            version = "0.9",
            metadata=[
                {"title": "LSCE", "href": "http://www.lsce.ipsl.fr/en/index.php"},
                {"title": "Documentation", "href": "http://flyingpigeon.readthedocs.io/en/latest/"},
                ],
            abstract="Weather Regimes detection based on trained reference statistics",
            statusSupported=True,
            storeSupported=True
            )

        self.resource = self.addComplexInput(
            identifier="resource",
            title="Resource",
            abstract="NetCDF File",
            minOccurs=1,
            maxOccurs=1000,
            maxmegabites=5000,
            formats=[{"mimeType":"application/x-netcdf"}],
            )

        self.Rdat = self.addLiteralInput(
            identifier="Rdat",
            title="R - workspace",
            abstract="R workspace as output from weather regime reference process",
            type=type(''),
            minOccurs=1,
            maxOccurs=1,
            # default=' http://api.gbif.org/v1/occurrence/download/request/0013848-160118175350007.zip'
            # maxmegabites=50,
            # formats=[{"mimeType":"application/zip"}],
            )

        self.dat = self.addLiteralInput(
            identifier="dat",
            title="R - datafile",
            abstract="R datafile as output from weather regime reference process",
            type=type(''),
            minOccurs=1,
            maxOccurs=1,
            # default=' http://api.gbif.org/v1/occurrence/download/request/0013848-160118175350007.zip'
            # maxmegabites=50,
            # formats=[{"mimeType":"application/zip"}],
            )

        self.netCDF = self.addLiteralInput(
            identifier="netCDF",
            title="netCDF reference",
            abstract="netCDF file as output from weather regime reference process",
            type=type(''),
            minOccurs=0,
            maxOccurs=1,
            # default=' http://api.gbif.org/v1/occurrence/download/request/0013848-160118175350007.zip'
            # maxmegabites=50,
            # formats=[{"mimeType":"application/zip"}],
            )

        # Literal Input Data
        # ------------------
        # self.BBox = self.addBBoxInput(
        #     identifier="BBox",
        #     title="Bounding Box",
        #     abstract="coordinates to define the region for weather classification",
        #     minOccurs=1,
        #     maxOccurs=1,
        #     default=[-80,50,22.5,70],
        #     crss=['EPSG:4326']
        #     )

        # self.BBox = self.addLiteralInput(
        #     identifier="BBox",
        #     title="Region",
        #     abstract="coordinates to define the region: (minlon,maxlon,minlat,maxlat)",
        #     default='-80,22.5,50,70', #  cdo syntax: 'minlon,maxlon,minlat,maxlat' ; ocgis syntax (minlon,minlat,maxlon,maxlat)
        #     type=type(''),
        #     minOccurs=1,
        #     maxOccurs=1,
        #     )

        self.season = self.addLiteralInput(
            identifier="season",
            title="Time region",
            abstract="Select the months to define the time region (all == whole year will be analysed)",
            default="DJF",
            type=type(''),
            minOccurs=1,
            maxOccurs=1,
            allowedValues= _TIMEREGIONS_.keys()
            )

        self.period = self.addLiteralInput(
            identifier="period",
            title="Period for weather regime calculation",
            abstract="Period for analysing the dataset",
            default="19700101-20101231",
            type=type(''),
            minOccurs=1,
            maxOccurs=1,
            )

        self.anualcycle = self.addLiteralInput(
            identifier="anualcycle",
            title="Period for annual cycle calculation",
            abstract="Period for annual cycle calculation",
            default="19700101-19991231",
            type=type(''),
            minOccurs=1,
            maxOccurs=1,
            )

        ######################
        ### define the outputs
        ######################

        # self.Routput_graphic = self.addComplexOutput(
        #     identifier="Routput_graphic",
        #     title="Graphics and Tables",
        #     abstract="Weather classification pressure map and frequency table",
        #     formats=[{"mimeType":"image/pdf"}],
        #     asReference=True,
        #     )
        
        self.output_pca = self.addComplexOutput(
            identifier="output_pca",
            title="PCA",
            abstract="Principal components",
            formats=[{"mimeType":"text/plain"}],
            asReference=True,
            )

        self.output_classification = self.addComplexOutput(
            identifier="output_classification",
            title="classification",
            abstract="Weather regime classification",
            formats=[{"mimeType":"application/octet-stream"}],
            asReference=True,
            )

        self.output_frequency = self.addComplexOutput(
            identifier="output_frequency",
            title="Frequency",
            abstract="Weather regime frequency values per year",
            formats=[{"mimeType":"text/plain"}],
            asReference=True,
            )        

        self.output_netcdf = self.addComplexOutput(
            identifier="output_netcdf",
            title="netCDF file",
            abstract="Prepared netCDF file as input for weather regime calculation",
            formats=[{"mimeType":"application/x-netcdf"}],
            asReference=True,
            )
    def __init__(self):
        inputs = [
            ComplexInput('resource', 'Resource',
                         abstract='NetCDF Files or archive (tar/zip) containing netCDF files.',
                         metadata=[Metadata('Info')],
                         min_occurs=1,
                         max_occurs=1000,
                         supported_formats=[
                             Format('application/x-netcdf'),
                             Format('application/x-tar'),
                             Format('application/zip'),
                         ]),

            # BoundingBoxInput('bbox', 'Bounding Box',
            #                  abstract='Bounding box to define the region for weather classification.'
            #                           ' Default: -80, 20, 50, 70.',
            #                  crss=['epsg:4326'],
            #                  min_occurs=0),

            LiteralInput("season", "Time region",
                         abstract="Select the months to define the time region (all == whole year will be analysed)",
                         default="DJF",
                         data_type='string',
                         min_occurs=1,
                         max_occurs=1,
                         allowed_values=_TIMEREGIONS_.keys()
                         ),

            LiteralInput("period", "Period for weatherregime calculation",
                         abstract="Period for analysing the dataset",
                         default="19700101-20101231",
                         data_type='string',
                         min_occurs=1,
                         max_occurs=1,
                         ),

            LiteralInput("anualcycle", "Period for anualcycle calculation",
                         abstract="Period for anual cycle calculation",
                         default="19700101-19991231",
                         data_type='string',
                         min_occurs=1,
                         max_occurs=1,
                         ),

            LiteralInput("kappa", "Nr of Weather regimes",
                         abstract="Set the number of clusters to be detected",
                         default='4',
                         data_type='integer',
                         min_occurs=1,
                         max_occurs=1,
                         allowed_values=range(2, 11)
                         ),
        ]

        outputs = [
            ComplexOutput("Routput_graphic", "Weather Regime Pressure map",
                          abstract="Weather Classification",
                          supported_formats=[Format('image/pdf')],
                          as_reference=True,
                          ),

            ComplexOutput("output_pca", "R - datafile",
                          abstract="Principal components (PCA)",
                          supported_formats=[Format('text/plain')],
                          as_reference=True,
                          ),

            ComplexOutput("output_classification", "R - workspace",
                          abstract="Weather regime classification",
                          supported_formats=[Format("application/octet-stream")],
                          as_reference=True,
                          ),

            ComplexOutput('output_netcdf', 'Subsets for one dataset',
                          abstract="Prepared netCDF file as input for weatherregime calculation",
                          as_reference=True,
                          supported_formats=[Format('application/x-netcdf')]
                          ),

            ComplexOutput('output_log', 'Logging information',
                          abstract="Collected logs during process run.",
                          as_reference=True,
                          supported_formats=[Format('text/plain')]
                          ),
        ]
        super(WeatherregimesmodelProcess, self).__init__(
            self._handler,
            identifier="weatherregimes_model",
            title="Weather Regimes (based on climate model data)",
            abstract='k-mean cluster analyse of the pressure patterns. Clusters are equivalent to weather regimes',
            version="0.10",
            metadata=[
                Metadata('LSCE', 'http://www.lsce.ipsl.fr/en/index.php'),
                Metadata('Doc', 'http://flyingpigeon.readthedocs.io/en/latest/'),
            ],
            inputs=inputs,
            outputs=outputs,
            status_supported=True,
            store_supported=True,
        )
Exemple #7
0
    def __init__(self):
        inputs = [
            ComplexInput('resource', 'Resource',
                         abstract='NetCDF Files or archive (tar/zip) containing netCDF files.',
                         metadata=[Metadata('Info')],
                         min_occurs=1,
                         max_occurs=1000,
                         supported_formats=[
                             Format('application/x-netcdf'),
                             Format('application/x-tar'),
                             Format('application/zip'),
                         ]),

            LiteralInput("Rdat", "R - workspace",
                         abstract="R workspace as output from weather regime reference process",
                         data_type='string',
                         min_occurs=1,
                         max_occurs=1,
                         ),

            LiteralInput("dat", "R - datafile",
                         abstract="R datafile as output from weather regime reference process",
                         data_type='string',
                         min_occurs=1,
                         max_occurs=1,
                         ),

            LiteralInput("netCDF", "netCDF reference",
                         abstract="netCDF file as output from weather regime reference process",
                         data_type='string',
                         min_occurs=0,
                         max_occurs=1,
                         ),

            LiteralInput("season", "Time region",
                         abstract="Select the months to define the time region (all == whole year will be analysed)",
                         default="DJF",
                         data_type='string',
                         min_occurs=1,
                         max_occurs=1,
                         allowed_values=_TIMEREGIONS_.keys()
                         ),

            LiteralInput("period", "Period for weatherregime calculation",
                         abstract="Period for analysing the dataset",
                         default="19700101-20101231",
                         data_type='string',
                         min_occurs=1,
                         max_occurs=1,
                         ),

            LiteralInput("anualcycle", "Period for anualcycle calculation",
                         abstract="Period for anual cycle calculation",
                         default="19700101-19991231",
                         data_type='string',
                         min_occurs=1,
                         max_occurs=1,
                         ), ]
        outputs = [
            ComplexOutput("output_pca", "R - datafile",
                          abstract="Principal components (PCA)",
                          supported_formats=[Format('text/plain')],
                          as_reference=True,
                          ),

            ComplexOutput("output_classification", "R - workspace",
                          abstract="Weather regime classification",
                          supported_formats=[Format("application/octet-stream")],
                          as_reference=True,
                          ),
            ComplexOutput("output_frequency", "Frequency",
                          abstract="Weather regime frequency values per year",
                          supported_formats=[Format('text/plain')],
                          as_reference=True,
                          ),

            ComplexOutput('output_netcdf', 'Subsets for one dataset',
                          abstract="Prepared netCDF file as input for weatherregime calculation",
                          as_reference=True,
                          supported_formats=[Format('application/x-netcdf')]
                          ),

            ComplexOutput('output_log', 'Logging information',
                          abstract="Collected logs during process run.",
                          as_reference=True,
                          supported_formats=[Format('text/plain')]
                          ),
        ]

        super(WeatherregimesprojectionProcess, self).__init__(
            self._handler,
            identifier="weatherregimes_projection",
            title="Weather Regimes (Projection based on precalculated statistics)",
            abstract='k-mean cluster analyse of the pressure patterns. Clusters are equivalent to weather regimes',
            version="0.10",
            metadata=[
                Metadata('LSCE', 'http://www.lsce.ipsl.fr/en/index.php'),
                Metadata('Doc', 'http://flyingpigeon.readthedocs.io/en/latest/'),
            ],
            inputs=inputs,
            outputs=outputs,
            status_supported=True,
            store_supported=True,
        )