majoplot 0.1.0__py3-none-any.whl

majoplot/domain/importers/XRD.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+import numpy as np
+
+from ..base import *
+
+class XRD:
+    instrument = "XRD"
+    
+    @classmethod
+    def fetch_raw_data(cls, raw_data_file:TextIO, raw_data_name:str)->Data|FAIL:
+        labels = LabelDict(
+            initital={"instrument":cls.instrument ,"raw_data": LabelValue(raw_data_name)},
+            )
+
+        # read
+        initial_pos = raw_data_file.tell()          # remember current position
+        first_line = raw_data_file.readline().strip()
+        match first_line:
+            case "<?xml version=\"1.0\" encoding=\"UTF-8\"?>":
+                # xrdml from XRD
+                import xml.etree.ElementTree as ET
+                from datetime import datetime
+                raw_data_file.seek(initial_pos)             # rewind to original position
+                _headers = ("2θ","I")
+                tree = ET.parse(raw_data_file)
+                root = tree.getroot()
+                # Get the default namespace URI from the root tag: "{uri}xrdMeasurements"
+                ns_uri = root.tag.split("}")[0].lstrip("{")
+                ns = {"x": ns_uri}
+                start = float(root.find(".//x:positions[@axis='2Theta']/x:startPosition", ns).text)
+                end   = float(root.find(".//x:positions[@axis='2Theta']/x:endPosition", ns).text)
+                ts_elem = root.find(".//x:startTimeStamp", ns)
+                ts = ts_elem.text.strip()
+                # Parse ISO 8601 with timezone offset
+                dt = datetime.fromisoformat(ts)
+
+                # Format date as YYYYMMDD
+                labels["date"] = dt.strftime("%Y%m%d")
+
+                intensities_text = root.find(".//x:intensities", ns).text
+                I = np.fromstring(intensities_text, sep=" ")
+                base = np.max(I) / 100
+                I = I / base
+                two_theta = np.linspace(start, end, I.size)
+                points = np.column_stack([two_theta, I])
+                labels["source"] = "experiment"
+                return Data(labels=labels, _headers=_headers, points=points)
+                
+
+            case "h    k    l      d (Å)      F(real)      F(imag)          |F|         2θ          I    M ID(λ) Phase":
+                # Refraction table from CIF by VESTA
+                _headers = ("2θ","I","h","k","l")
+                indexs = {"2θ":7,"I":8,"h":0,"k":1,"l":2}
+                points = []
+                for line in raw_data_file:
+                    cells = line.split()
+                    points.append([float(cells[indexs[head]]) for head in _headers])
+                labels["source"] = "cif"
+                return Data(labels=labels,_headers=_headers,points=np.array(points))
+
+            case _:
+                return fail_signal

majoplot/domain/muti_axes_spec.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+from typing import NamedTuple
+from dataclasses import dataclass, field
+import numpy as np
+from itertools import chain
+
+from .base import * 
+
+class InsertAxesSpec(NamedTuple):
+    x:float
+    y:float
+    width:float
+    height:float
+    legend_holder:str="last axes"
+
+    @classmethod
+    def default(cls, figure_size:tuple[float], axes_pool:list[Axes])->InsertAxesSpec:
+        POINT_BOX = 0.01
+        MARGIN_SCALE_OFFSET = 0.05
+        PIXEL_NUM = 20
+        INSERT_MARGIN_SCALE = 0.8
+        MARGIN_CENTER_OFFSET = 0.85
+        INSERT_TOP_PIXEL_MARGEN = 0
+        INSERT_RIGHT_PIXEL_MARGEN = 0
+        FAIL_AREA_THRESHOLD = 0.1
+        ASPECT_RATIO = 1
+
+        if len(axes_pool) > 2:
+            return fail_signal
+        main = axes_pool[0]
+
+        # collect scatters in main
+        main_scatters = chain.from_iterable(data.points_for_plot for data in main.data_pool)
+        
+        # get the xlim, ylim of main
+        xlim = main.xlim
+        ylim = main.ylim
+        x_span_min = main.spec.x_log_scale_min_span
+        y_span_min = main.spec.y_log_scale_min_span
+        if xlim[0] > 0 and xlim[1] > 0 and (xlim[1] / xlim[0]) >= x_span_min:
+            xlim = (np.log10(xlim[0]), np.log10(xlim[1]))
+        if ylim[0] > 0 and ylim[0] > 0 and (ylim[1] / ylim[0]) >= y_span_min:
+            ylim = (np.log10(ylim[0]), np.log10(ylim[1]))
+
+        width = xlim[1] - xlim[0]
+        height = ylim[1] - ylim[0]
+        x_offset = width * MARGIN_SCALE_OFFSET
+        y_offset = height * MARGIN_SCALE_OFFSET
+        width += x_offset * 2
+        height += y_offset *2
+
+
+        # Examine the occupation situation
+        occ = np.zeros((PIXEL_NUM, PIXEL_NUM))
+        box_t = lambda n: min(n,PIXEL_NUM-1)
+        box_b = lambda n: max(n,0)
+        for scatter in main_scatters:
+            x,y = scatter[:2]
+            x_pos = (x - xlim[0] + x_offset)/width
+            y_pos = (y - ylim[0] + y_offset)/height
+            xbox = (x_pos - POINT_BOX, x_pos + POINT_BOX)
+            ybox = (y_pos - POINT_BOX, y_pos + POINT_BOX)
+            x_pixel_box = range(box_b(np.int_(xbox[0]*PIXEL_NUM)), box_t(np.int_(xbox[1]*PIXEL_NUM)+1))
+            y_pixel_box = range(box_b(np.int_(ybox[0]*PIXEL_NUM)), box_t(np.int_(ybox[1]*PIXEL_NUM)+1))
+            for i in x_pixel_box:
+                for j in y_pixel_box:
+                    occ[j,i] = 1
+
+        # matrix to histograms
+        histograms = np.zeros((PIXEL_NUM, PIXEL_NUM))
+        for x in range(PIXEL_NUM):
+            for y in range(PIXEL_NUM):
+                h = 0
+                for i in reversed(range(y+1)):
+                    if occ[i,x] == 0:
+                        h+=1
+                    else:
+                        break
+                histograms[y, x] = h
+        import matplotlib.pyplot as plt
+        @dataclass(slots=True)
+        class Rectangle:
+            x0:int|np.int_
+            x1:int|np.int_
+            y1:int|np.int_
+            h:int|np.int_
+            w:int|np.int_ = field(init=False,default=0)
+            taller:bool = field(init=False,default=False)
+            S:float|np.float64 = field(init=False,default=0)
+
+            def __post_init__(self):
+                self.w = self.x1 - self.x0 + 1
+                self_aspect_ratio = self.h / self.w
+                if self_aspect_ratio < ASPECT_RATIO:
+                    self.taller = False
+                    self.S = self.h ** 2 / ASPECT_RATIO
+                else:
+                    self.taller = True
+                    self.S = self.w ** 2 * ASPECT_RATIO
+                
+
+        largest_rec = Rectangle(PIXEL_NUM-1,PIXEL_NUM-1,PIXEL_NUM-1,histograms[PIXEL_NUM-1,PIXEL_NUM-1])
+
+        for y in reversed(range(PIXEL_NUM)):
+            x_stack = []
+            for x in reversed(range(-1,PIXEL_NUM)):
+                cur_h = histograms[y, x] if x != -1 else 0
+                while x_stack:
+                    top_x = x_stack[-1]
+                    h = histograms[y, top_x]
+
+                    if cur_h >= h:
+                        break
+
+                    x_stack.pop()
+
+                    right = x_stack[-1]-1 if x_stack else PIXEL_NUM-1
+                    cur_rec = Rectangle(
+                        x0=x+1,
+                        x1=right,
+                        y1=y,
+                        h=h
+                    )
+                    if cur_rec.S > largest_rec.S:
+                        largest_rec = cur_rec
+                x_stack.append(x)                
+
+
+        # calculate the final rec para (anchor on left bottom)
+        p_x = (largest_rec.x0 - INSERT_RIGHT_PIXEL_MARGEN) / PIXEL_NUM
+        p_y = (largest_rec.y1-largest_rec.h - INSERT_TOP_PIXEL_MARGEN) / PIXEL_NUM
+        p_w = largest_rec.w / PIXEL_NUM 
+        p_h = largest_rec.h / PIXEL_NUM
+
+        margined_S = largest_rec.S / ( PIXEL_NUM ** 2 ) * ( INSERT_MARGIN_SCALE ** 2)
+        if margined_S < FAIL_AREA_THRESHOLD:
+            return fail_signal
+
+        if largest_rec.taller:
+            adjusted_x = p_x
+            adjusted_y = p_y + p_h - p_w * ASPECT_RATIO
+            margin_c_x = adjusted_x + p_w * MARGIN_CENTER_OFFSET
+            margin_c_y = adjusted_y + p_w * ASPECT_RATIO * MARGIN_CENTER_OFFSET
+            margined_w = p_w * INSERT_MARGIN_SCALE
+            margined_h = margined_w * ASPECT_RATIO
+        else:
+            adjusted_x = p_x + p_w - p_h / ASPECT_RATIO
+            adjusted_y = p_y
+            margin_c_x = adjusted_x + p_h / ASPECT_RATIO * MARGIN_CENTER_OFFSET
+            margin_c_y = adjusted_y + p_h * MARGIN_CENTER_OFFSET
+            margined_h = p_h * INSERT_MARGIN_SCALE
+            margined_w = margined_h / ASPECT_RATIO
+        margined_x = (adjusted_x - margin_c_x) * INSERT_MARGIN_SCALE + margin_c_x
+        margined_y = (adjusted_y - margin_c_y) * INSERT_MARGIN_SCALE + margin_c_y
+        
+        return InsertAxesSpec(
+            legend_holder="last axes",
+            x=margined_x,
+            y=margined_y,
+            width=margined_w,
+            height=margined_h,
+        )
+
+
+        
+class DualYAxesSpec(NamedTuple):
+    legend_holder = "figure"
+
+class StackAxesSpec(NamedTuple):
+    legend_holder = "axes_self"
+    nrows:int
+    ncols:int

majoplot/domain/scenarios/PPMS_Resistivity/RT.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from ...base import *
+
+
+FIGSIZE = (8, 6)
+
+T = "Temperature (K)"
+H = "Magnetic Field (Oe)"
+R = "Resistivity (Ohm-m)"
+RI ={
+    1: {"R":"Bridge 1 Resistivity (Ohm-m)", "I":"Bridge 1 Excitation (uA)"},
+    2: {"R":"Bridge 2 Resistivity (Ohm-m)", "I":"Bridge 2 Excitation (uA)"},
+    3: {"R":"Bridge 3 Resistivity (Ohm-m)", "I":"Bridge 3 Excitation (uA)"},
+}
+
+class RT:
+    data_summary_label_names = ["H"]
+    axes_label_names = ("date", "raw_data", "bridge", "sample_name")
+    figure_label_names = ("date", "raw_data", "bridge", "sample_name")
+    figure_summary_label_names = ("raw_data","bridge","sample_name")
+    max_axes_in_one_figure = 1
+    project_to_child_folder_label_names = {"date":"sample_name"}
+    parent_folder_name = "RT"
+
+    @classmethod
+    def preprocess(cls, raw_datas:list[Data])->list[Data]:
+        datas = []
+        for raw_data in raw_datas:
+            raw_labels = raw_data.labels
+            headers = raw_data.headers
+            raw_points = raw_data.points
+            
+            # Split by H
+            split_datas = []
+
+            last_H_stage = round(raw_points[0][headers[H]])
+            current_points = [ last_H_stage, [ raw_points[0] ] ]
+
+            for point in raw_points[1:]:
+                cur_H_stage = round(point[headers[H]])
+                if cur_H_stage != last_H_stage:
+                    split_datas.append(current_points)
+                    last_H_stage = cur_H_stage
+                    current_points = [ last_H_stage, [ point ] ]
+                else:
+                    current_points[1].append(point)
+            else:
+                split_datas.append(current_points)
+
+            # 3 bridges
+            for H_stage, points in split_datas:
+                for i in range(1,4):
+                    _headerTRI = (T,RI[i]["R"],RI[i]["I"])
+                    _headers = (T,RI[i]["R"])
+                    s_points = [ [point[headers[x]] for x in _headerTRI] for point in points]
+                    # clear null R points
+                    s_points = np.array([point for point in s_points if point[1]])
+                    # record
+                    Imin = np.min(s_points[:,1])
+                    Imax = np.max(s_points[:,1])
+                    if (Imax - Imin) / Imax < 0.03:
+                        Irange = f"{np.mean(s_points[:,1]):.1e}"
+                    else:
+                        Irange = f"{Imin:.1e}~{Imax:.1e}"
+                    labels = LabelDict()
+                    labels["instrument"] = raw_labels["instrument"]
+                    labels["raw_data"] = raw_labels["raw_data"]
+                    labels["date"] = raw_labels["date"]
+                    labels["bridge"] = LabelValue(i,unit="Bridge",unit_as_postfix=False)
+                    labels["sample_name"] = raw_labels[f"sample{i}_name"]
+                    labels["sample_units"] = raw_labels[f"sample{i}_units"]
+                    labels["H"] = LabelValue(H_stage, unit="Oe")
+                    labels["I_range"] = LabelValue(Irange,unit="μA")
+                    labels.summary_names = cls.data_summary_label_names
+                    datas.append(Data(
+                        labels=labels,
+                        _headers=_headers,
+                        points=s_points[:,0:2],
+                        ignore_outliers=IgnoreOutlierSpec(min_gap_base=1e-6,min_gap_multiple=10),
+                    ))
+            
+        return datas
+            
+            
+
+    @classmethod
+    def make_axes_spec(cls, axes_labels)->AxesSpec:
+        return AxesSpec(
+            x_axis_title=T,
+            y_axis_title=R,
+            major_grid=None,
+            major_tick=TickSpec(),
+            legend=LegendSpec(fontsize=5),
+        )
+            
+
+    @classmethod
+    def make_figure_spec(cls,figure_labels, axes_pool:Iterable[Axes])->FigureSpec:
+        figure_name = figure_labels.brief_summary
+
+        return FigureSpec(
+            name=figure_name,
+            title=None,
+            figsize=FIGSIZE,
+            linestyle_cycle= ("-",),
+            linecolor_cycle = (
+                "#2d0b59", "#3b0f6f", "#4a136e", "#5a176e", "#6a1c6e",
+                "#7a216f", "#8b2770", "#9b2d71", "#ac3372", "#bd3973",
+                "#ce4074", "#df4775", "#f04f76", "#f86a5a", "#fb8c3c",
+                "#fdbb2d", "#fcfdbf",
+                ),
+            linemarker_cycle = ("o","s","^","v","d","*","x","+"),
+            alpa_cycle = (1.0,),
+        )
+    
+    @classmethod
+    def make_muti_axes_spec(cls, axes_pool:list[Axes])->MutiAxesSpec|FAIL|None:
+        return None

majoplot/domain/scenarios/VSM/MT.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+from copy import copy
+
+from ...base import *
+
+
+FIGSIZE = (8, 6)
+
+T = "Temperature (K)"
+M = "DC Moment Free Ctr (emu)"
+H = "Magnetic Field (Oe)"
+
+
+class MT:
+    data_summary_label_names = ["H","cooling_type"]
+    axes_label_names = ("material","date","raw_data", "H")
+    figure_label_names = ("material","date", "raw_data","H")
+    figure_summary_label_names = ("raw_data","date")
+    max_axes_in_one_figure = 1
+    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
+            headers = raw_data.headers
+            raw_points = raw_data.points
+            iT = headers[T]
+            iH = headers[H]
+            iM = headers[M]
+            
+            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
+                datas.append(
+                    Data(
+                        labels=labels,
+                        _headers=(T,M),
+                        points=np.array(current_points)[:,[iT,iM]],
+                        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)->AxesSpec:
+        return AxesSpec(
+            x_axis_title=T,
+            y_axis_title=M,
+            major_grid=None,
+            major_tick=TickSpec(),
+            legend=LegendSpec(),
+        )
+            
+
+    @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,
+            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 None

majoplot/domain/scenarios/VSM/MT_insert.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+from copy import copy
+
+from ...base import *
+from ...muti_axes_spec import InsertAxesSpec
+
+
+FIGSIZE = (8, 6)
+
+T = "Temperature (K)"
+M = "DC Moment Free Ctr (emu)"
+H = "Magnetic Field (Oe)"
+
+
+class MT_insert:
+    data_summary_label_names = ["H","cooling_type"]
+    axes_label_names = ("material","date","raw_data", "H")
+    figure_label_names = ("material","date", "raw_data")
+    figure_summary_label_names = ("raw_data","date")
+    max_axes_in_one_figure = 2
+    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
+            headers = raw_data.headers
+            raw_points = raw_data.points
+            iT = headers[T]
+            iH = headers[H]
+            iM = headers[M]
+            
+            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
+                datas.append(
+                    Data(
+                        labels=labels,
+                        _headers=(T,M),
+                        points=np.array(current_points)[:,[iT,iM]],
+                        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)->AxesSpec:
+        return AxesSpec(
+            x_axis_title=T,
+            y_axis_title=M,
+            major_grid=None,
+            major_tick=TickSpec(),
+            legend=LegendSpec(),
+        )
+            
+
+    @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,
+            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:
+        if len(axes_pool) == 2:
+            return InsertAxesSpec.default(FIGSIZE, axes_pool)
+        else:
+            return None