majoplot 0.1.0__py3-none-any.whl

majoplot/domain/scenarios/VSM/MT_reliability_analysis.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+from copy import copy
+
+from ...base import *
+from ...muti_axes_spec import StackAxesSpec
+
+
+FIGSIZE = (10, 10)
+
+T = "Temperature (K)"
+H = "Magnetic Field (Oe)"
+
+M = "DC Moment Free Ctr (emu)"
+Mfit = "DC Free Fit"
+Mfix = "DC Moment Fixed Ctr (emu)"
+SD = "DC Squid Drift"
+CP = "Center Position (mm)"
+DCC = "DC Calculated Center (mm)"
+
+_headers_group = [
+    (T,M),   (T,Mfix),
+    (T,Mfit),(T,SD),
+    (T,CP),  (T,DCC),
+]
+
+class MT_reliability_analysis:
+    data_summary_label_names = ["H","cooling_type"]
+    axes_label_names = ("material","date","raw_data", "H", "Y_axis")
+    figure_label_names = ("material","date", "raw_data","H")
+    figure_summary_label_names = ("raw_data","date")
+    max_axes_in_one_figure = 0
+    project_to_child_folder_label_names = {"material":"date","date":"material"}
+    parent_folder_name = "MT"
+
+    @classmethod
+    def preprocess(cls, raw_datas:list[Data])->list[Data]:
+        datas = []
+        for raw_data in raw_datas:
+            raw_labels = raw_data.labels
+            raw_headers = raw_data.headers
+            raw_points = raw_data.points
+            iT = raw_headers[T]
+            iH = raw_headers[H]
+            
+            check_deque = []
+
+            current_points = []
+            current_cool_type = "ZFC"
+            try:
+                current_points.append(raw_points[0])
+                H_stage = round(raw_points[0, iH])
+            except KeyError:
+                return []
+
+            def append_data():
+                nonlocal current_points, check_deque, datas
+                nonlocal current_cool_type
+                current_points.append(check_deque.pop(0))
+                labels = copy(raw_labels)
+                labels["H"] = LabelValue(H_stage, "Oe")
+                if current_points[-1][iT] < current_points[0][iT]:
+                    unused = True
+                    labels["cooling_type"] = "cooling"
+                else:
+                    unused = False
+                    if current_cool_type == "ZFC":
+                        labels["cooling_type"] = "ZFC"
+                        current_cool_type = "FC"
+                    else:
+                        labels["cooling_type"] = "FC"
+                        current_cool_type = "ZFC"
+                labels["scenario"] = "MT"
+                labels.summary_names = cls.data_summary_label_names
+                current_points_array = np.array(current_points)
+                for _headers in _headers_group:
+                    special_labels = copy(labels)
+                    special_labels["Y_axis"] = _headers[1]
+                    datas.append(
+                        Data(
+                            labels=special_labels,
+                            _headers=_headers,
+                            points=current_points_array[:,[iT,raw_headers[_headers[1]]]],
+                            ignore_outliers=IgnoreOutlierSpec(
+                                min_gap_base=5e-7,
+                                min_gap_multiple=10
+                            ),
+                            unused=unused,
+                    ))
+
+            for point in raw_points[1:]:
+                check_deque.append(point)
+                if len(check_deque) == 2:
+                    # not the same H?
+                    if abs(check_deque[1][iH] - H_stage) > 2:
+                        append_data()
+                        current_points = [check_deque.pop()]
+                        H_stage = round(current_points[0][iH])
+                        current_cool_type = "ZFC"
+                    # not the same heating curve?
+                    elif (check_deque[0][iT] - current_points[0][iT])>2 and (check_deque[0][iT] - check_deque[1][iT])>2:
+                        append_data()
+                        current_points = [check_deque.pop()]
+                    else:
+                        # the same curve
+                        current_points.append(check_deque.pop(0))
+            else:
+                while check_deque:
+                    append_data()
+        return datas
+
+
+    @classmethod
+    def make_axes_spec(cls,axes_labels:LabelDict)->AxesSpec:
+        return AxesSpec(
+            x_axis_title=T,
+            y_axis_title=axes_labels["Y_axis"],
+            axis_title_font_size=6,
+            major_grid=None,
+            major_tick=TickSpec(),
+            legend=LegendSpec(fontsize=4),
+        )
+            
+
+    @classmethod
+    def make_figure_spec(cls,figure_labels, axes_pool:Iterable[Axes])->FigureSpec:
+        H_stages = {}
+        for axes in axes_pool:
+            H_stages[axes.labels["H"]] = None
+        
+        figure_name = f"{figure_labels.brief_summary}-{",".join(str(H_stage) for H_stage in H_stages)}"
+
+        return FigureSpec(
+            name=figure_name,
+            title=None,
+            global_fontsize=6,
+            figsize=FIGSIZE,
+            linestyle_cycle= ("-", "--"),
+            linecolor_cycle = ("black", "red"),
+            linemarker_cycle = ("o","o","s","s","^","^","v","v","d","d","*","*","x","x","+","+"),
+            alpa_cycle = (1.0,),
+        )
+    
+    @classmethod
+    def make_muti_axes_spec(cls, axes_pool:list[Axes])->MutiAxesSpec|FAIL|None:
+        return StackAxesSpec(nrows=3, ncols=2)

majoplot/domain/scenarios/XRD/Compare.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+from copy import deepcopy
+
+from ...base import *
+from ...muti_axes_spec import StackAxesSpec
+
+
+FIGSIZE = (8, 6)
+STACK_FIGSIZE = (8,4)
+
+class Compare:
+    """
+        EXP_RAW1, EXP_RAW2, CIF_RAW1, EXP_RAW3 CIF_RAW2
+        ->
+        StackFigure(
+            Axes1( EXP_DATA1, CIF_DATA1 ),
+            Axes2( EXP_DATA2, CIF_DATA1 ),
+            Axes3( EXP_DATA3, CIF_DATA1 ),
+        )
+    """
+    data_summary_label_names = ["raw_data"]
+    standard_summary_label_names = ["standard_name"]
+    axes_label_names = ("raw_data","date","standard_name")
+    figure_label_names = ("date","standard_name")
+    figure_summary_label_names = ("date","standard_name")
+    max_axes_in_one_figure = 0
+    project_to_child_folder_label_names = {"date":None}
+    parent_folder_name = "XRD"
+
+    @classmethod
+    def preprocess(cls, raw_datas:list[Data])->list[Data]:
+        _headers = ("2θ","I")
+        standard_raw_data = None
+        raw_experiment_datas = []
+        for raw_data in raw_datas:
+            if raw_data.labels["source"] == "cif":
+                if standard_raw_data == None:
+                    standard_labels = raw_data.labels
+                    standard_points = raw_data.points[:,0:2]
+                    standard_raw_data = Data(labels=standard_labels, _headers=_headers,points=standard_points)
+            else:
+                raw_experiment_datas.append(raw_data)
+        
+        _headers = ()
+        if raw_experiment_datas:
+            com_date = raw_experiment_datas[-1].labels["date"]
+        datas = []
+        for raw_data in raw_experiment_datas:
+            labels = LabelDict()
+            labels["instrument"] = raw_data.labels["instrument"]
+            labels["raw_data"] = raw_data.labels["raw_data"]
+            labels["date"] = com_date
+            if standard_raw_data:
+                labels["standard_name"] = standard_raw_data.labels["raw_data"]
+            else:
+                labels["standard_name"] = ""
+            experiment_labels = deepcopy(labels)
+            experiment_labels.summary_names = cls.data_summary_label_names
+            datas.append(
+                Data(labels=experiment_labels, _headers=_headers, points=raw_data.points)
+            )
+            if standard_raw_data:
+                standard_labels = deepcopy(labels)
+                standard_labels.summary_names = cls.standard_summary_label_names
+                xmin, xmax = raw_data.xlim
+                mask = (standard_raw_data.points[:,0] >= xmin) & (standard_raw_data.points[:, 0] <= xmax)
+                datas.append(
+                    Data(labels=standard_labels, _headers=_headers, points=standard_raw_data.points[mask])
+                )
+        return datas
+
+    @classmethod
+    def make_axes_spec(cls, axes_labels)->AxesSpec:
+        return AxesSpec(
+            x_axis_title="2θ",
+            y_axis_title="I",
+            major_grid=None,
+            major_tick=TickSpec(),
+            legend=LegendSpec(),
+        )
+            
+
+    @classmethod
+    def make_figure_spec(cls,figure_labels, axes_pool:Iterable[Axes])->FigureSpec:
+        figure_name = figure_labels.brief_summary
+        figsize = FIGSIZE if len(axes_pool)<2 else STACK_FIGSIZE
+
+        return FigureSpec(
+            name=figure_name,
+            title=None,
+            figsize=figsize,
+            linestyle_cycle= ("-","|"),
+            linecolor_cycle = ("black","red"),
+            linemarker_cycle = (None,),
+            alpa_cycle = (1.0,),
+        )
+    
+    @classmethod
+    def make_muti_axes_spec(cls, axes_pool:list[Axes])->MutiAxesSpec|FAIL|None:
+        count = len(axes_pool)
+        if count < 2:
+            return None
+        else:
+            return StackAxesSpec(nrows=count, ncols=1)

majoplot/domain/utils.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+from typing import Iterator
+from .base import *
+
+# ========= Axes and Figures ========
+def group_into_axes(all_datas:Iterable[Data], scenario:Scenario)->list[Axes]:
+    axes_label_names = scenario.axes_label_names
+    make_axes_spec = scenario.make_axes_spec
+
+    axes_labels_and_data_pools, _ = LabelDict.group(
+        ((data.labels, data) for data in all_datas if not data.unused),
+        group_label_names=axes_label_names,
+    )
+    axes_pool = []
+    for axes_labels, data_pool in axes_labels_and_data_pools:  
+        spec = make_axes_spec(axes_labels)
+        axes_pool.append(Axes(spec, axes_labels, data_pool))
+    return axes_pool
+
+
+def group_into_figure(all_axes:Iterable[Axes], scenario:Scenario)->list[Figure]:
+    figure_label_names = scenario.figure_label_names
+    make_figure_spec = scenario.make_figure_spec
+    make_muti_axes_spec = scenario.make_muti_axes_spec
+    summary_label_names = scenario.figure_summary_label_names
+    max_axes_in_one_figure = scenario.max_axes_in_one_figure
+
+    labels_and_axes_pools, _ = LabelDict.group(
+        ((axes.labels, axes) for axes in all_axes),
+        group_label_names=figure_label_names,
+        summary_label_names= summary_label_names,
+        group_member_limit=max_axes_in_one_figure
+    )
+
+    figure_pool = []
+    for labels, axes_pool in labels_and_axes_pools:
+        spec = make_figure_spec(labels, axes_pool)
+        muti_axes_spec = make_muti_axes_spec(axes_pool)
+        
+        proj_folder = {}
+        for proj_label_name, child_folder_label_name in scenario.project_to_child_folder_label_names.items():
+            p_name = str(labels.get(proj_label_name, ""))
+            if not p_name:
+                p_name = "UNTITLED"
+            f_name = str(labels.get(child_folder_label_name, ""))
+            proj_folder[p_name] = f"{scenario.parent_folder_name}/{f_name}"
+
+        if muti_axes_spec is fail_signal:
+            for i, axes in enumerate(axes_pool):
+                figure_pool.append(
+                    Figure(
+                        axes_pool=[axes],
+                        spec=spec._replace(name=f"{spec.name}_{i}"),
+                        muti_axes_spec=None,
+                        labels=labels,
+                        proj_folder= proj_folder
+                        )
+                )
+            continue
+
+        figure_pool.append(
+            Figure(
+                axes_pool=axes_pool,
+                spec=spec,
+                muti_axes_spec=muti_axes_spec,
+                labels=labels,
+                proj_folder= proj_folder
+                )
+            )
+            
+
+    return figure_pool
+
+# ======== Project ========
+def pack_into_project(all_figures:Iterable[Figure])->dict[str,Project]:
+    projs = {}
+    for figure in all_figures:
+        figure_name = figure.spec.name
+        for proj_name,folder_name in figure.proj_folder.items():
+            projs.setdefault(proj_name, Project()).setdefault(folder_name, folder())[figure_name] = figure
+    return projs
+
+# ======== Importers ========
+def skip_lines_then_readline(fp:TextIO, skip_lines: int)->str:
+    for _ in range(skip_lines):
+        fp.readline()
+    return fp.readline()