def Write_out(self, filename=None, overwrite="ask"):
"""
Writes the treated data to a file
"""
if filename is None:
if self["H"] == "0.0" or self["symmetrize"] is False:
filename = self["filename"].replace(".dat", "-treated.dat")
else:
filename = self["filename"].replace(".dat", "-sym-treated.dat")
else:
filename = os.path.abspath(filename)
parameters1 = ["sample", "date", "mount", "probe", "H"]
parameters2 = ["w", "t", "L"]
measures = ["T_av", "T0", "Tp", "Tm", "dTx", "kxx", "dTy", "kxy"]
columns = ["T_av(K)", "T0(K)", "T+(K)", "T-(K)",
"dTx(K)", "kxx(W/Km)", "dTy(K)", "kxy(W/Km)"]
if self["H"] == "0.0":
measures = measures[0:6]
columns = columns[0:6]
else:
pass
columns = "\t".join(columns)
comments1 = "\n".join(["%s\t=\t%s" % (i, self[i])
for i in parameters1])
comments2 = "\n".join(["%s\t=\t%1.3e" % (i, self[i])
for i in parameters2])
header = comments1+"\n"+comments2+"\n"+columns
data = np.array([self[i] for i in measures]).T
U.write_to_file(filename, data, header, overwrite=overwrite)
def Plot_fancy(self, *args, **kwargs):
"""
Just like Plot_all but with a fancy layout that is more suited to
ipython notebooks
"""
remove = ["T_av", "T0", "Tp", "Tm", "I_fit", "T0_fit"]
measures = [i for i in self.measures if i not in remove]
ref_meas = ["kxx", "kxx/T", "kxy", "kxy/kxx", "dTx",
"dTx/T", "dTy", "dTy/dTx", "Resistance", "Tp_Tm"]
measures = [i for i in ref_meas if i in measures]
n = len(measures)
fig, ax = V.create_grid(n)
try:
show = kwargs["show"]
kwargs.pop("show")
except KeyError:
show = None
try:
filename = kwargs["filename"]
kwargs.pop("filename")
except KeyError:
filename = None
try:
overwrite = kwargs["overwrite"]
kwargs.pop("overwrite")
except KeyError:
overwrite = "ask"
for i in range(n):
self.Plot(measures[i], *args, show=None,
fig=fig, ax=ax[i], **kwargs)
if hasattr(self, "__sample") is True:
plt.suptitle(self["sample"], y=0.95, fontsize=22)
else:
pass
fig.tight_layout(rect=[0.01, 0.01, 1, 0.96])
if filename is not None:
filename = os.path.abspath(filename)
U.save_to_pdf(filename, fig, overwrite=overwrite)
else:
pass
if show is True:
plt.show()
elif show is False:
plt.close()
else:
pass
return fig, ax
def Plot_all(self, *args, **kwargs):
"""
Plots all non trivial measures, all the same kwargs as Conductivity.Plot
with the addition of filename to save the file.
"""
remove = ["T_av", "T0", "Tp", "Tm", "T0_fit", "I_fit"]
measures = [i for i in self.measures if i not in remove]
figures = []
try:
filename = kwargs["filename"]
kwargs.pop("filename")
except KeyError:
filename = None
try:
overwrite = kwargs["overwrite"]
kwargs.pop("overwrite")
except KeyError:
overwrite = "ask"
for key in measures:
figures.append(self.Plot(key, *args, **kwargs)[0])
if filename is not None:
filename = os.path.abspath(filename)
U.save_to_pdf(filename, figures, overwrite=overwrite)
else:
pass
return
def __init__(self, filename=None, w=1e-6, t=1e-6, L=1e-6, sign=1, **kwargs):
self.parameters = []
self.measures = []
self.raw_data = []
# Check for some specific kwargs and update kwargs
self["force_kxy"], kwargs = self.__check_force_kxy(**kwargs)
self["symmetrize"], kwargs = self.__check_symmetrize(**kwargs)
self["sign"] = self.__check_sign(sign)
self["gain"], kwargs = self.__check_gain(**kwargs)
if filename is not None:
filename = os.path.abspath(filename)
self["filename"] = filename
self["filetype"] = self.__check_filetype(filename)
# Find info
self.__add_parameters(w, t, L)
# If the file contains raw data
if self["filetype"] == "raw":
# If symmetrize is True
if self["H"] != "0.0" and self["symmetrize"] is True:
filename2 = U.get_symetric_file(filename)
raw_data = self.__Symmetrize(filename, filename2)
elif self["H"] != "0.0" and self["symmetrize"] is False:
if filename.find("--") != -1:
self["H"] = "-"+self["H"]
raw_data = U.read_file_raw(filename)
else:
raw_data = U.read_file_raw(filename)
else:
raw_data = U.read_file_raw(filename)
for key, values in raw_data.items():
self[key] = values
self.raw_data.append(key)
self.__Analyze(self["gain"])
self.__add_measure()
# If the file contains treated data
elif self["filetype"] == "treated":
data = U.read_file_treated(filename)
for key, values in data.items():
self[key] = values
self.measures.append(key)
self.__add_measure()
# Remaining kwargs are set as parameters
for key, value in kwargs.items():
self[key] = value
self.parameters.append(key)
return
def __init__(self, filename=None):
# Importing dictionaries
self["dict_measures"] = D.log_data_dict
self["dict_parameters"] = D.parameters_dict
# Initializing lists
self.measures = []
self.parameters = []
if filename is not None:
# Read the file
filename = os.path.abspath(filename)
header = U.read_header(filename)
# Find the parameters
self["H"] = U.find_H(filename)
self["date"] = U.find_date(filename)
self["mount"] = U.find_mount(filename)
self["probe"] = U.find_probe(filename, header)
self["sample"] = U.find_sample(filename, header)
self.parameters += ["H", "date", "mount", "probe", "sample"]
# Find the measurements
log_data = U.read_file_log(filename)
for key, value in log_data.items():
self[key] = value
self.measures.append(key)
return
def __init__(self, filename=None, **kwargs):
"""
Used to initialize a Measurement object
Parameters:
------------------------------------------------------------------------
filename : str
The path to the file containing the data to be read and stored.
Can be relative or absolute.
Useful kwargs:
------------------------------------------------------------------------
H, w, t, L : int or float
The value of the magnetic field used during the experiment and
the geometric parameters of the sample. Note that kwargs are
case sensitive and are used to populate the parameters attribute
of the object
sample : str
The name of the sample.
"""
self.measures = []
self.parameters = []
if filename is not None:
filename = os.path.abspath(filename)
data = U.read_file_treated(filename)
header = U.read_header(filename)
for key, value in data.items():
self[key] = value
self.measures.append(key)
self["H"] = U.find_H(filename, header)
self["date"] = U.find_date(filename, header)
self["mount"] = U.find_mount(filename, header)
self["sample"] = U.find_sample(filename, header)
self["probe"] = U.find_probe(filename, header)
self.parameters += ["H", "date", "mount", "sample", "probe"]
for key, value in kwargs.items():
self[key] = value
if key not in self.parameters:
self.parameters.append(key)
if hasattr(self, "__sample") is False:
setattr(self, "__sample", "unknown")
else:
pass
if hasattr(self, "__H") is False:
setattr(self, "__H", "unknown")
else:
pass
self.__add_measure()
return
def __add_parameters(self, width, thickness, length):
filename = self["filename"]
header = U.read_header(filename)
parameters = []
# Geometric parameters
self["w"] = width
self["t"] = thickness
self["L"] = length
# Other parameters
self["H"] = U.find_H(filename, header)
self["date"] = U.find_date(filename, header)
self["mount"] = U.find_mount(filename, header)
self["sample"] = U.find_sample(filename, header)
self["probe"] = U.find_probe(filename, header)
# Add to parameters
parameters += ["H", "date", "mount", "sample", "probe"]
parameters += ["w", "t", "L"]
self.parameters += parameters
return
def __Symmetrize(self, filename, filename2):
anti_sym = ["dTy_0", "dTy_Q"]
if filename.find("--") != -1:
filename, filename2 = filename2, filename
else:
pass
data = U.read_file_raw(filename)
data2 = U.read_file_raw(filename2)
sym_data = dict()
for key, values in data.items():
if key in data2:
if key in anti_sym:
sym_data[key] = 0.5*(data[key]-data2[key])
else:
sym_data[key] = 0.5*(data[key]+data2[key])
else:
pass
return sym_data
def __check_filetype(self, filename):
filename = os.path.abspath(filename)
columns = U.read_header(filename)[-1].split("\t")
raw_data = 0
measures = 0
for key, values in self.__dict_raw.items():
for v in values:
if v in columns:
raw_data += 1
else:
measures += 1
if raw_data > measures:
filetype = "raw"
else:
filetype = "treated"
return filetype
def Plot_fancy(self, *args, **kwargs):
"""
Just like Plot_all but with a fancy layout that is more suited to
ipython notebooks
"""
remove = ["T_av", "T0", "Tp", "Tm"]
if len(self.measurements) > 1:
remove.append("Tp_Tm")
else:
pass
measures = [i for i in self.measures if i not in remove]
ref_meas = [
"kxx", "kxx/T", "kxy", "kxy/T", "dTx", "dTx/T", "dTy", "dTy/dTx",
"Resistance"
]
measures = [i for i in ref_meas if i in measures]
n = len(measures)
fig, ax = V.create_grid(n)
try:
show = kwargs["show"]
kwargs.pop("show")
except KeyError:
show = True
# Tries to find sample name
if "sample" in self.parameters:
sample = self.measurements[0]["sample"]
for m in self.measurements:
if sample == m["sample"]:
pass
else:
sample = None
break
try:
filename = kwargs["filename"]
kwargs.pop("filename")
except KeyError:
filename = None
try:
overwrite = kwargs["overwrite"]
kwargs.pop("overwrite")
except KeyError:
overwrite = "ask"
for i in range(n):
self.Plot(measures[i],
*args,
show=None,
fig=fig,
ax=ax[i],
**kwargs)
if sample is not None:
plt.suptitle(sample, y=0.95, fontsize=22)
else:
pass
fig.tight_layout(rect=[0.01, 0.01, 1, 0.95])
if filename is not None:
filename = os.path.abspath(filename)
U.save_to_pdf(filename, fig, overwrite=overwrite)
else:
pass
if show is True:
plt.show()
elif show is False:
plt.close()
else:
pass
return fig, ax
def Current(self, _min, _max, deg=5, T_max=100, N=100, *args, **kwargs):
"""
Used to compute the optimal current function for the sample.
Parameters:
------------------------------------------------------------------------
_min, _max: int or float
The min/max of dT/T in percentages
deg: int
The degree of the polynomial fit
T_max: int or float
T0 max for the plot
N: int
Number of points in the plot
"""
directory = os.path.split(self["filename"])[0]
rnge = "%1.0f%s_to_%1.0f%s.dat" % (_min, "%", _max, "%")
name = "_".join([self["sample"].replace(" ", "_"), "dTovT", rnge])
datafile = os.path.join(directory, name)
n = self["T_av"].shape[0]
dT_T = np.linspace(_min/100, _max/100, n)
alpha = self["w"]*self["t"]/self["L"]
I = np.sqrt(self["kxx"]*alpha*self["T_av"]*dT_T/5000)
coeff_I = np.polyfit(self["T0"], I, deg)
poly_func = np.poly1d(coeff_I)
T0 = np.linspace(0, T_max, N)
I_fit = poly_func(T0)
self["T0_fit"] = T0
self["I_fit"] = I_fit*1000
self["coeff_I"] = coeff_I
self.measures += ["T0_fit", "I_fit"]
# Looks for show as kwarg
try:
show = kwargs["show"]
if type(show) is not bool:
if show is not None:
raise TypeError("show must be of type bool or None")
else:
kwargs.pop("show")
else:
kwargs.pop("show")
except KeyError:
show = True
try:
filename = kwargs["filename"]
kwargs.pop("filename")
except KeyError:
filename = None
label = r"$\Delta$ T / T from %1.2f%s to %1.2f%s" % (
_min, "%", _max, "%")
fig, ax = self.Plot("I_fit", x_axis="T0_fit", show=None, parameters=[])
plt.figtext(1-0.005, 0.005, label, fontsize=14,
va="baseline", ha="right")
if show is True:
plt.show()
elif show is False:
plt.close()
else:
pass
if filename is not None:
filename = os.path.abspath(filename)
U.save_to_pdf(filename, fig)
else:
pass
try:
write = kwargs["write"]
kwargs.pop("write")
except KeyError:
write = True
if write is True:
degrees = np.array([i for i in range(coeff_I.shape[0])])
data = np.array([degrees, coeff_I[::-1]]).T
header = "Current function coefficients\norder\tcoeff"
U.write_to_file(datafile, data, header, fmt=["%i", "%,18e"])
else:
pass
return