def _doAlignMarkers(self):
        """
        Prepare and invoke alignment to markers.
        """
        fieldmodule = self._fitter._fieldmodule
        markerGroup = self._fitter.getMarkerGroup()
        assert markerGroup, "Align:  No marker group to align with"
        markerPrefix = markerGroup.getName()
        modelCoordinates = self._fitter.getModelCoordinatesField()
        componentsCount = modelCoordinates.getNumberOfComponents()

        markerNodeGroup, markerLocation, markerCoordinates, markerName = self._fitter.getMarkerModelFields(
        )
        assert markerNodeGroup and markerCoordinates and markerName, "Align:  No marker group, coordinates or name fields"
        modelMarkers = getNodeNameCentres(markerNodeGroup, markerCoordinates,
                                          markerName)

        markerDataGroup, markerDataCoordinates, markerDataName = self._fitter.getMarkerDataFields(
        )
        assert markerDataGroup and markerDataCoordinates and markerDataName, "Align:  No marker data group, coordinates or name fields"
        dataMarkers = getNodeNameCentres(markerDataGroup,
                                         markerDataCoordinates, markerDataName)

        # match model and data markers, warn of unmatched markers
        markerMap = {}
        writeDiagnostics = self.getDiagnosticLevel() > 0
        for modelName in modelMarkers:
            # name match allows case and whitespace differences
            matchName = modelName.strip().casefold()
            for dataName in dataMarkers:
                if dataName.strip().casefold() == matchName:
                    markerMap[modelName] = (modelMarkers[modelName],
                                            dataMarkers[dataName])
                    if writeDiagnostics:
                        print("Align:  Model marker '" + modelName +
                              "' found in data" +
                              (" as '" + dataName +
                               "'" if (dataName != modelName) else ""))
                        dataMarkers.pop(dataName)
                    break
            else:
                if writeDiagnostics:
                    print("Align:  Model marker '" + modelName +
                          "' not found in data")
        if writeDiagnostics:
            for dataName in dataMarkers:
                print("Align:  Data marker '" + dataName +
                      "' not found in model")

        self._optimiseAlignment(markerMap)
    def _doAlignMarkers(self):
        """
        Prepare and invoke alignment to markers.
        """
        fieldmodule = self._fitter._fieldmodule
        markerGroup = self._fitter.getMarkerGroup()
        assert markerGroup, "Align:  No marker group to align with"
        markerPrefix = markerGroup.getName()
        modelCoordinates = self._fitter.getModelCoordinatesField()
        componentsCount = modelCoordinates.getNumberOfComponents()

        markerNodeGroup, markerLocation, markerCoordinates, markerName = self._fitter.getMarkerModelFields(
        )
        assert markerNodeGroup and markerCoordinates and markerName, "Align:  No marker group, coordinates or name fields"
        modelMarkers = getNodeNameCentres(markerNodeGroup, markerCoordinates,
                                          markerName)

        markerDataGroup, markerDataCoordinates, markerDataName = self._fitter.getMarkerDataFields(
        )
        assert markerDataGroup and markerDataCoordinates and markerDataName, "Align:  No marker data group, coordinates or name fields"
        dataMarkers = getNodeNameCentres(markerDataGroup,
                                         markerDataCoordinates, markerDataName)

        # match model and data markers, warn of missing markers
        markerMap = {}
        for name, modelx in modelMarkers.items():
            datax = dataMarkers.get(name)
            if datax:
                markerMap[name] = (modelx, datax)
        if self.getDiagnosticLevel() > 0:
            for name in modelMarkers:
                datax = dataMarkers.get(name)
                if datax:
                    print("Align:  Found marker " + name +
                          " in model and data")
            for name in modelMarkers:
                if not markerMap.get(name):
                    print("Align:  Model marker " + name +
                          " not found in data")
            for name in dataMarkers:
                if not markerMap.get(name):
                    print("Align:  Data marker " + name +
                          " not found in model")

        self._optimiseAlignment(markerMap)
    def _doAutoAlign(self):
        """
        Perform auto alignment to groups and/or markers.
        """
        modelCoordinates = self._fitter.getModelCoordinatesField()
        componentsCount = modelCoordinates.getNumberOfComponents()
        pointMap = {
        }  # dict group/marker name -> (modelCoordinates, dataCoordinates)

        if self._alignGroups:
            fieldmodule = self._fitter._fieldmodule
            datapoints = fieldmodule.findNodesetByFieldDomainType(
                Field.DOMAIN_TYPE_DATAPOINTS)
            dataCoordinates = self._fitter.getDataCoordinatesField()
            groups = get_group_list(fieldmodule)
            with ChangeManager(fieldmodule):
                one = fieldmodule.createFieldConstant(1.0)
                for group in groups:
                    dataGroup = self._fitter.getGroupDataProjectionNodesetGroup(
                        group)
                    if not dataGroup:
                        continue
                    meshGroup = self._fitter.getGroupDataProjectionMeshGroup(
                        group)
                    if not meshGroup:
                        continue
                    groupName = group.getName()
                    meanDataCoordinates = evaluate_field_nodeset_mean(
                        dataCoordinates, dataGroup)
                    coordinates_integral = evaluate_field_mesh_integral(
                        modelCoordinates, modelCoordinates, meshGroup)
                    mass = evaluate_field_mesh_integral(
                        one, modelCoordinates, meshGroup)
                    meanModelCoordinates = div(coordinates_integral, mass)
                    pointMap[groupName] = (meanModelCoordinates,
                                           meanDataCoordinates)
                del one

        if self._alignMarkers:
            markerGroup = self._fitter.getMarkerGroup()
            assert markerGroup, "Align:  No marker group to align with"
            markerPrefix = markerGroup.getName()

            markerNodeGroup, markerLocation, markerCoordinates, markerName = self._fitter.getMarkerModelFields(
            )
            assert markerNodeGroup and markerCoordinates and markerName, "Align:  No marker group, coordinates or name fields"
            modelMarkers = getNodeNameCentres(markerNodeGroup,
                                              markerCoordinates, markerName)

            markerDataGroup, markerDataCoordinates, markerDataName = self._fitter.getMarkerDataFields(
            )
            assert markerDataGroup and markerDataCoordinates and markerDataName, "Align:  No marker data group, coordinates or name fields"
            dataMarkers = getNodeNameCentres(markerDataGroup,
                                             markerDataCoordinates,
                                             markerDataName)

            # match model and data markers, warn of unmatched markers
            writeDiagnostics = self.getDiagnosticLevel() > 0
            for modelName in modelMarkers:
                # name match allows case and whitespace differences
                matchName = modelName.strip().casefold()
                for dataName in dataMarkers:
                    if dataName.strip().casefold() == matchName:
                        pointMap[modelName] = (modelMarkers[modelName],
                                               dataMarkers[dataName])
                        if writeDiagnostics:
                            print("Align:  Model marker '" + modelName +
                                  "' found in data" +
                                  (" as '" + dataName +
                                   "'" if (dataName != modelName) else ""))
                            dataMarkers.pop(dataName)
                        break
                else:
                    if writeDiagnostics:
                        print("Align:  Model marker '" + modelName +
                              "' not found in data")
            if writeDiagnostics:
                for dataName in dataMarkers:
                    print("Align:  Data marker '" + dataName +
                          "' not found in model")

        self._optimiseAlignment(pointMap)