partition
stringclasses 3
values | func_name
stringlengths 1
134
| docstring
stringlengths 1
46.9k
| path
stringlengths 4
223
| original_string
stringlengths 75
104k
| code
stringlengths 75
104k
| docstring_tokens
listlengths 1
1.97k
| repo
stringlengths 7
55
| language
stringclasses 1
value | url
stringlengths 87
315
| code_tokens
listlengths 19
28.4k
| sha
stringlengths 40
40
|
|---|---|---|---|---|---|---|---|---|---|---|---|
valid
|
scanABFfolder
|
scan an ABF directory and subdirectory. Try to do this just once.
Returns ABF files, SWHLab files, and groups.
|
doc/oldcode/swhlab/core/common.py
|
def scanABFfolder(abfFolder):
"""
scan an ABF directory and subdirectory. Try to do this just once.
Returns ABF files, SWHLab files, and groups.
"""
assert os.path.isdir(abfFolder)
filesABF=forwardSlash(sorted(glob.glob(abfFolder+"/*.*")))
filesSWH=[]
if os.path.exists(abfFolder+"/swhlab4/"):
filesSWH=forwardSlash(sorted(glob.glob(abfFolder+"/swhlab4/*.*")))
groups=getABFgroups(filesABF)
return filesABF,filesSWH,groups
|
def scanABFfolder(abfFolder):
"""
scan an ABF directory and subdirectory. Try to do this just once.
Returns ABF files, SWHLab files, and groups.
"""
assert os.path.isdir(abfFolder)
filesABF=forwardSlash(sorted(glob.glob(abfFolder+"/*.*")))
filesSWH=[]
if os.path.exists(abfFolder+"/swhlab4/"):
filesSWH=forwardSlash(sorted(glob.glob(abfFolder+"/swhlab4/*.*")))
groups=getABFgroups(filesABF)
return filesABF,filesSWH,groups
|
[
"scan",
"an",
"ABF",
"directory",
"and",
"subdirectory",
".",
"Try",
"to",
"do",
"this",
"just",
"once",
".",
"Returns",
"ABF",
"files",
"SWHLab",
"files",
"and",
"groups",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/common.py#L631-L642
|
[
"def",
"scanABFfolder",
"(",
"abfFolder",
")",
":",
"assert",
"os",
".",
"path",
".",
"isdir",
"(",
"abfFolder",
")",
"filesABF",
"=",
"forwardSlash",
"(",
"sorted",
"(",
"glob",
".",
"glob",
"(",
"abfFolder",
"+",
"\"/*.*\"",
")",
")",
")",
"filesSWH",
"=",
"[",
"]",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"abfFolder",
"+",
"\"/swhlab4/\"",
")",
":",
"filesSWH",
"=",
"forwardSlash",
"(",
"sorted",
"(",
"glob",
".",
"glob",
"(",
"abfFolder",
"+",
"\"/swhlab4/*.*\"",
")",
")",
")",
"groups",
"=",
"getABFgroups",
"(",
"filesABF",
")",
"return",
"filesABF",
",",
"filesSWH",
",",
"groups"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
getParent
|
given an ABF file name, return the ABF of its parent.
|
doc/oldcode/swhlab/core/common.py
|
def getParent(abfFname):
"""given an ABF file name, return the ABF of its parent."""
child=os.path.abspath(abfFname)
files=sorted(glob.glob(os.path.dirname(child)+"/*.*"))
parentID=abfFname #its own parent
for fname in files:
if fname.endswith(".abf") and fname.replace(".abf",".TIF") in files:
parentID=os.path.basename(fname).replace(".abf","")
if os.path.basename(child) in fname:
break
return parentID
|
def getParent(abfFname):
"""given an ABF file name, return the ABF of its parent."""
child=os.path.abspath(abfFname)
files=sorted(glob.glob(os.path.dirname(child)+"/*.*"))
parentID=abfFname #its own parent
for fname in files:
if fname.endswith(".abf") and fname.replace(".abf",".TIF") in files:
parentID=os.path.basename(fname).replace(".abf","")
if os.path.basename(child) in fname:
break
return parentID
|
[
"given",
"an",
"ABF",
"file",
"name",
"return",
"the",
"ABF",
"of",
"its",
"parent",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/common.py#L644-L654
|
[
"def",
"getParent",
"(",
"abfFname",
")",
":",
"child",
"=",
"os",
".",
"path",
".",
"abspath",
"(",
"abfFname",
")",
"files",
"=",
"sorted",
"(",
"glob",
".",
"glob",
"(",
"os",
".",
"path",
".",
"dirname",
"(",
"child",
")",
"+",
"\"/*.*\"",
")",
")",
"parentID",
"=",
"abfFname",
"#its own parent",
"for",
"fname",
"in",
"files",
":",
"if",
"fname",
".",
"endswith",
"(",
"\".abf\"",
")",
"and",
"fname",
".",
"replace",
"(",
"\".abf\"",
",",
"\".TIF\"",
")",
"in",
"files",
":",
"parentID",
"=",
"os",
".",
"path",
".",
"basename",
"(",
"fname",
")",
".",
"replace",
"(",
"\".abf\"",
",",
"\"\"",
")",
"if",
"os",
".",
"path",
".",
"basename",
"(",
"child",
")",
"in",
"fname",
":",
"break",
"return",
"parentID"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
getParent2
|
given an ABF and the groups dict, return the ID of its parent.
|
doc/oldcode/swhlab/core/common.py
|
def getParent2(abfFname,groups):
"""given an ABF and the groups dict, return the ID of its parent."""
if ".abf" in abfFname:
abfFname=os.path.basename(abfFname).replace(".abf","")
for parentID in groups.keys():
if abfFname in groups[parentID]:
return parentID
return abfFname
|
def getParent2(abfFname,groups):
"""given an ABF and the groups dict, return the ID of its parent."""
if ".abf" in abfFname:
abfFname=os.path.basename(abfFname).replace(".abf","")
for parentID in groups.keys():
if abfFname in groups[parentID]:
return parentID
return abfFname
|
[
"given",
"an",
"ABF",
"and",
"the",
"groups",
"dict",
"return",
"the",
"ID",
"of",
"its",
"parent",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/common.py#L656-L663
|
[
"def",
"getParent2",
"(",
"abfFname",
",",
"groups",
")",
":",
"if",
"\".abf\"",
"in",
"abfFname",
":",
"abfFname",
"=",
"os",
".",
"path",
".",
"basename",
"(",
"abfFname",
")",
".",
"replace",
"(",
"\".abf\"",
",",
"\"\"",
")",
"for",
"parentID",
"in",
"groups",
".",
"keys",
"(",
")",
":",
"if",
"abfFname",
"in",
"groups",
"[",
"parentID",
"]",
":",
"return",
"parentID",
"return",
"abfFname"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
getNotesForABF
|
given an ABF, find the parent, return that line of experiments.txt
|
doc/oldcode/swhlab/core/common.py
|
def getNotesForABF(abfFile):
"""given an ABF, find the parent, return that line of experiments.txt"""
parent=getParent(abfFile)
parent=os.path.basename(parent).replace(".abf","")
expFile=os.path.dirname(abfFile)+"/experiment.txt"
if not os.path.exists(expFile):
return "no experiment file"
with open(expFile) as f:
raw=f.readlines()
for line in raw:
if line[0]=='~':
line=line[1:].strip()
if line.startswith(parent):
while "\t\t" in line:
line=line.replace("\t\t","\t")
line=line.replace("\t","\n")
return line
return "experiment.txt found, but didn't contain %s"%parent
|
def getNotesForABF(abfFile):
"""given an ABF, find the parent, return that line of experiments.txt"""
parent=getParent(abfFile)
parent=os.path.basename(parent).replace(".abf","")
expFile=os.path.dirname(abfFile)+"/experiment.txt"
if not os.path.exists(expFile):
return "no experiment file"
with open(expFile) as f:
raw=f.readlines()
for line in raw:
if line[0]=='~':
line=line[1:].strip()
if line.startswith(parent):
while "\t\t" in line:
line=line.replace("\t\t","\t")
line=line.replace("\t","\n")
return line
return "experiment.txt found, but didn't contain %s"%parent
|
[
"given",
"an",
"ABF",
"find",
"the",
"parent",
"return",
"that",
"line",
"of",
"experiments",
".",
"txt"
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/common.py#L665-L682
|
[
"def",
"getNotesForABF",
"(",
"abfFile",
")",
":",
"parent",
"=",
"getParent",
"(",
"abfFile",
")",
"parent",
"=",
"os",
".",
"path",
".",
"basename",
"(",
"parent",
")",
".",
"replace",
"(",
"\".abf\"",
",",
"\"\"",
")",
"expFile",
"=",
"os",
".",
"path",
".",
"dirname",
"(",
"abfFile",
")",
"+",
"\"/experiment.txt\"",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"expFile",
")",
":",
"return",
"\"no experiment file\"",
"with",
"open",
"(",
"expFile",
")",
"as",
"f",
":",
"raw",
"=",
"f",
".",
"readlines",
"(",
")",
"for",
"line",
"in",
"raw",
":",
"if",
"line",
"[",
"0",
"]",
"==",
"'~'",
":",
"line",
"=",
"line",
"[",
"1",
":",
"]",
".",
"strip",
"(",
")",
"if",
"line",
".",
"startswith",
"(",
"parent",
")",
":",
"while",
"\"\\t\\t\"",
"in",
"line",
":",
"line",
"=",
"line",
".",
"replace",
"(",
"\"\\t\\t\"",
",",
"\"\\t\"",
")",
"line",
"=",
"line",
".",
"replace",
"(",
"\"\\t\"",
",",
"\"\\n\"",
")",
"return",
"line",
"return",
"\"experiment.txt found, but didn't contain %s\"",
"%",
"parent"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
getABFgroups
|
given a list of ALL files (not just ABFs), return a dict[ID]=[ID,ID,ID].
Parents are determined if a .abf matches a .TIF.
This is made to assign children files to parent ABF IDs.
|
doc/oldcode/swhlab/core/common.py
|
def getABFgroups(files):
"""
given a list of ALL files (not just ABFs), return a dict[ID]=[ID,ID,ID].
Parents are determined if a .abf matches a .TIF.
This is made to assign children files to parent ABF IDs.
"""
children=[]
groups={}
for fname in sorted(files):
if fname.endswith(".abf"):
if fname.replace(".abf",".TIF") in files: #TODO: cap sensitive
if len(children):
groups[children[0]]=children
children=[os.path.basename(fname)[:-4]]
else:
children.append(os.path.basename(fname)[:-4])
groups[children[0]]=children
#print(" -- found %d groups of %d ABFs"%(len(groups),len(files)))
return groups
|
def getABFgroups(files):
"""
given a list of ALL files (not just ABFs), return a dict[ID]=[ID,ID,ID].
Parents are determined if a .abf matches a .TIF.
This is made to assign children files to parent ABF IDs.
"""
children=[]
groups={}
for fname in sorted(files):
if fname.endswith(".abf"):
if fname.replace(".abf",".TIF") in files: #TODO: cap sensitive
if len(children):
groups[children[0]]=children
children=[os.path.basename(fname)[:-4]]
else:
children.append(os.path.basename(fname)[:-4])
groups[children[0]]=children
#print(" -- found %d groups of %d ABFs"%(len(groups),len(files)))
return groups
|
[
"given",
"a",
"list",
"of",
"ALL",
"files",
"(",
"not",
"just",
"ABFs",
")",
"return",
"a",
"dict",
"[",
"ID",
"]",
"=",
"[",
"ID",
"ID",
"ID",
"]",
".",
"Parents",
"are",
"determined",
"if",
"a",
".",
"abf",
"matches",
"a",
".",
"TIF",
".",
"This",
"is",
"made",
"to",
"assign",
"children",
"files",
"to",
"parent",
"ABF",
"IDs",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/common.py#L684-L702
|
[
"def",
"getABFgroups",
"(",
"files",
")",
":",
"children",
"=",
"[",
"]",
"groups",
"=",
"{",
"}",
"for",
"fname",
"in",
"sorted",
"(",
"files",
")",
":",
"if",
"fname",
".",
"endswith",
"(",
"\".abf\"",
")",
":",
"if",
"fname",
".",
"replace",
"(",
"\".abf\"",
",",
"\".TIF\"",
")",
"in",
"files",
":",
"#TODO: cap sensitive",
"if",
"len",
"(",
"children",
")",
":",
"groups",
"[",
"children",
"[",
"0",
"]",
"]",
"=",
"children",
"children",
"=",
"[",
"os",
".",
"path",
".",
"basename",
"(",
"fname",
")",
"[",
":",
"-",
"4",
"]",
"]",
"else",
":",
"children",
".",
"append",
"(",
"os",
".",
"path",
".",
"basename",
"(",
"fname",
")",
"[",
":",
"-",
"4",
"]",
")",
"groups",
"[",
"children",
"[",
"0",
"]",
"]",
"=",
"children",
"#print(\" -- found %d groups of %d ABFs\"%(len(groups),len(files)))",
"return",
"groups"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
getIDfileDict
|
given a list of files, return a dict[ID]=[files].
This is made to assign children files to parent ABF IDs.
|
doc/oldcode/swhlab/core/common.py
|
def getIDfileDict(files):
"""
given a list of files, return a dict[ID]=[files].
This is made to assign children files to parent ABF IDs.
"""
d={}
orphans=[]
for fname in files:
if fname.endswith(".abf"):
d[os.path.basename(fname)[:-4]]=[]
for fname in files:
if fname.endswith(".html") or fname.endswith(".txt"):
continue #don't try to assign to an ABF
if len(os.path.basename(fname).split(".")[0])>=8:
ID = os.path.basename(fname)[:8] #ABF ID (first several chars)
else:
ID = os.path.basename(fname).split(".")[0] #short filename, just not extension
if ID in d.keys():
d[ID]=d[ID]+[fname]
else:
orphans.append(os.path.basename(fname))
#print(" ?? orphan file",ID,os.path.basename(fname))
if orphans:
print(" ?? found %d orphan files"%len(orphans))
return d
|
def getIDfileDict(files):
"""
given a list of files, return a dict[ID]=[files].
This is made to assign children files to parent ABF IDs.
"""
d={}
orphans=[]
for fname in files:
if fname.endswith(".abf"):
d[os.path.basename(fname)[:-4]]=[]
for fname in files:
if fname.endswith(".html") or fname.endswith(".txt"):
continue #don't try to assign to an ABF
if len(os.path.basename(fname).split(".")[0])>=8:
ID = os.path.basename(fname)[:8] #ABF ID (first several chars)
else:
ID = os.path.basename(fname).split(".")[0] #short filename, just not extension
if ID in d.keys():
d[ID]=d[ID]+[fname]
else:
orphans.append(os.path.basename(fname))
#print(" ?? orphan file",ID,os.path.basename(fname))
if orphans:
print(" ?? found %d orphan files"%len(orphans))
return d
|
[
"given",
"a",
"list",
"of",
"files",
"return",
"a",
"dict",
"[",
"ID",
"]",
"=",
"[",
"files",
"]",
".",
"This",
"is",
"made",
"to",
"assign",
"children",
"files",
"to",
"parent",
"ABF",
"IDs",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/common.py#L704-L728
|
[
"def",
"getIDfileDict",
"(",
"files",
")",
":",
"d",
"=",
"{",
"}",
"orphans",
"=",
"[",
"]",
"for",
"fname",
"in",
"files",
":",
"if",
"fname",
".",
"endswith",
"(",
"\".abf\"",
")",
":",
"d",
"[",
"os",
".",
"path",
".",
"basename",
"(",
"fname",
")",
"[",
":",
"-",
"4",
"]",
"]",
"=",
"[",
"]",
"for",
"fname",
"in",
"files",
":",
"if",
"fname",
".",
"endswith",
"(",
"\".html\"",
")",
"or",
"fname",
".",
"endswith",
"(",
"\".txt\"",
")",
":",
"continue",
"#don't try to assign to an ABF",
"if",
"len",
"(",
"os",
".",
"path",
".",
"basename",
"(",
"fname",
")",
".",
"split",
"(",
"\".\"",
")",
"[",
"0",
"]",
")",
">=",
"8",
":",
"ID",
"=",
"os",
".",
"path",
".",
"basename",
"(",
"fname",
")",
"[",
":",
"8",
"]",
"#ABF ID (first several chars)",
"else",
":",
"ID",
"=",
"os",
".",
"path",
".",
"basename",
"(",
"fname",
")",
".",
"split",
"(",
"\".\"",
")",
"[",
"0",
"]",
"#short filename, just not extension",
"if",
"ID",
"in",
"d",
".",
"keys",
"(",
")",
":",
"d",
"[",
"ID",
"]",
"=",
"d",
"[",
"ID",
"]",
"+",
"[",
"fname",
"]",
"else",
":",
"orphans",
".",
"append",
"(",
"os",
".",
"path",
".",
"basename",
"(",
"fname",
")",
")",
"#print(\" ?? orphan file\",ID,os.path.basename(fname))",
"if",
"orphans",
":",
"print",
"(",
"\" ?? found %d orphan files\"",
"%",
"len",
"(",
"orphans",
")",
")",
"return",
"d"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
getIDsFromFiles
|
given a path or list of files, return ABF IDs.
|
doc/oldcode/swhlab/core/common.py
|
def getIDsFromFiles(files):
"""given a path or list of files, return ABF IDs."""
if type(files) is str:
files=glob.glob(files+"/*.*")
IDs=[]
for fname in files:
if fname[-4:].lower()=='.abf':
ext=fname.split('.')[-1]
IDs.append(os.path.basename(fname).replace('.'+ext,''))
return sorted(IDs)
|
def getIDsFromFiles(files):
"""given a path or list of files, return ABF IDs."""
if type(files) is str:
files=glob.glob(files+"/*.*")
IDs=[]
for fname in files:
if fname[-4:].lower()=='.abf':
ext=fname.split('.')[-1]
IDs.append(os.path.basename(fname).replace('.'+ext,''))
return sorted(IDs)
|
[
"given",
"a",
"path",
"or",
"list",
"of",
"files",
"return",
"ABF",
"IDs",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/common.py#L730-L739
|
[
"def",
"getIDsFromFiles",
"(",
"files",
")",
":",
"if",
"type",
"(",
"files",
")",
"is",
"str",
":",
"files",
"=",
"glob",
".",
"glob",
"(",
"files",
"+",
"\"/*.*\"",
")",
"IDs",
"=",
"[",
"]",
"for",
"fname",
"in",
"files",
":",
"if",
"fname",
"[",
"-",
"4",
":",
"]",
".",
"lower",
"(",
")",
"==",
"'.abf'",
":",
"ext",
"=",
"fname",
".",
"split",
"(",
"'.'",
")",
"[",
"-",
"1",
"]",
"IDs",
".",
"append",
"(",
"os",
".",
"path",
".",
"basename",
"(",
"fname",
")",
".",
"replace",
"(",
"'.'",
"+",
"ext",
",",
"''",
")",
")",
"return",
"sorted",
"(",
"IDs",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
inspectABF
|
May be given an ABF object or filename.
|
doc/oldcode/swhlab/core/common.py
|
def inspectABF(abf=exampleABF,saveToo=False,justPlot=False):
"""May be given an ABF object or filename."""
pylab.close('all')
print(" ~~ inspectABF()")
if type(abf) is str:
abf=swhlab.ABF(abf)
swhlab.plot.new(abf,forceNewFigure=True)
if abf.sweepInterval*abf.sweeps<60*5: #shorter than 5 minutes
pylab.subplot(211)
pylab.title("%s [%s]"%(abf.ID,abf.protoComment))
swhlab.plot.sweep(abf,'all')
pylab.subplot(212)
swhlab.plot.sweep(abf,'all',continuous=True)
swhlab.plot.comments(abf)
else:
print(" -- plotting as long recording")
swhlab.plot.sweep(abf,'all',continuous=True,minutes=True)
swhlab.plot.comments(abf,minutes=True)
pylab.title("%s [%s]"%(abf.ID,abf.protoComment))
swhlab.plot.annotate(abf)
if justPlot:
return
if saveToo:
path=os.path.split(abf.fname)[0]
basename=os.path.basename(abf.fname)
pylab.savefig(os.path.join(path,"_"+basename.replace(".abf",".png")))
pylab.show()
return
|
def inspectABF(abf=exampleABF,saveToo=False,justPlot=False):
"""May be given an ABF object or filename."""
pylab.close('all')
print(" ~~ inspectABF()")
if type(abf) is str:
abf=swhlab.ABF(abf)
swhlab.plot.new(abf,forceNewFigure=True)
if abf.sweepInterval*abf.sweeps<60*5: #shorter than 5 minutes
pylab.subplot(211)
pylab.title("%s [%s]"%(abf.ID,abf.protoComment))
swhlab.plot.sweep(abf,'all')
pylab.subplot(212)
swhlab.plot.sweep(abf,'all',continuous=True)
swhlab.plot.comments(abf)
else:
print(" -- plotting as long recording")
swhlab.plot.sweep(abf,'all',continuous=True,minutes=True)
swhlab.plot.comments(abf,minutes=True)
pylab.title("%s [%s]"%(abf.ID,abf.protoComment))
swhlab.plot.annotate(abf)
if justPlot:
return
if saveToo:
path=os.path.split(abf.fname)[0]
basename=os.path.basename(abf.fname)
pylab.savefig(os.path.join(path,"_"+basename.replace(".abf",".png")))
pylab.show()
return
|
[
"May",
"be",
"given",
"an",
"ABF",
"object",
"or",
"filename",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/common.py#L741-L768
|
[
"def",
"inspectABF",
"(",
"abf",
"=",
"exampleABF",
",",
"saveToo",
"=",
"False",
",",
"justPlot",
"=",
"False",
")",
":",
"pylab",
".",
"close",
"(",
"'all'",
")",
"print",
"(",
"\" ~~ inspectABF()\"",
")",
"if",
"type",
"(",
"abf",
")",
"is",
"str",
":",
"abf",
"=",
"swhlab",
".",
"ABF",
"(",
"abf",
")",
"swhlab",
".",
"plot",
".",
"new",
"(",
"abf",
",",
"forceNewFigure",
"=",
"True",
")",
"if",
"abf",
".",
"sweepInterval",
"*",
"abf",
".",
"sweeps",
"<",
"60",
"*",
"5",
":",
"#shorter than 5 minutes",
"pylab",
".",
"subplot",
"(",
"211",
")",
"pylab",
".",
"title",
"(",
"\"%s [%s]\"",
"%",
"(",
"abf",
".",
"ID",
",",
"abf",
".",
"protoComment",
")",
")",
"swhlab",
".",
"plot",
".",
"sweep",
"(",
"abf",
",",
"'all'",
")",
"pylab",
".",
"subplot",
"(",
"212",
")",
"swhlab",
".",
"plot",
".",
"sweep",
"(",
"abf",
",",
"'all'",
",",
"continuous",
"=",
"True",
")",
"swhlab",
".",
"plot",
".",
"comments",
"(",
"abf",
")",
"else",
":",
"print",
"(",
"\" -- plotting as long recording\"",
")",
"swhlab",
".",
"plot",
".",
"sweep",
"(",
"abf",
",",
"'all'",
",",
"continuous",
"=",
"True",
",",
"minutes",
"=",
"True",
")",
"swhlab",
".",
"plot",
".",
"comments",
"(",
"abf",
",",
"minutes",
"=",
"True",
")",
"pylab",
".",
"title",
"(",
"\"%s [%s]\"",
"%",
"(",
"abf",
".",
"ID",
",",
"abf",
".",
"protoComment",
")",
")",
"swhlab",
".",
"plot",
".",
"annotate",
"(",
"abf",
")",
"if",
"justPlot",
":",
"return",
"if",
"saveToo",
":",
"path",
"=",
"os",
".",
"path",
".",
"split",
"(",
"abf",
".",
"fname",
")",
"[",
"0",
"]",
"basename",
"=",
"os",
".",
"path",
".",
"basename",
"(",
"abf",
".",
"fname",
")",
"pylab",
".",
"savefig",
"(",
"os",
".",
"path",
".",
"join",
"(",
"path",
",",
"\"_\"",
"+",
"basename",
".",
"replace",
"(",
"\".abf\"",
",",
"\".png\"",
")",
")",
")",
"pylab",
".",
"show",
"(",
")",
"return"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
ftp_login
|
return an "FTP" object after logging in.
|
doc/oldcode/swhlab/core/common.py
|
def ftp_login(folder=None):
"""return an "FTP" object after logging in."""
pwDir=os.path.realpath(__file__)
for i in range(3):
pwDir=os.path.dirname(pwDir)
pwFile = os.path.join(pwDir,"passwd.txt")
print(" -- looking for login information in:\n [%s]"%pwFile)
try:
with open(pwFile) as f:
lines=f.readlines()
username=lines[0].strip()
password=lines[1].strip()
print(" -- found a valid username/password")
except:
print(" -- password lookup FAILED.")
username=TK_askPassword("FTP LOGIN","enter FTP username")
password=TK_askPassword("FTP LOGIN","enter password for %s"%username)
if not username or not password:
print(" !! failed getting login info. aborting FTP effort.")
return
print(" username:",username)
print(" password:","*"*(len(password)))
print(" -- logging in to FTP ...")
try:
ftp = ftplib.FTP("swharden.com")
ftp.login(username, password)
if folder:
ftp.cwd(folder)
return ftp
except:
print(" !! login failure !!")
return False
|
def ftp_login(folder=None):
"""return an "FTP" object after logging in."""
pwDir=os.path.realpath(__file__)
for i in range(3):
pwDir=os.path.dirname(pwDir)
pwFile = os.path.join(pwDir,"passwd.txt")
print(" -- looking for login information in:\n [%s]"%pwFile)
try:
with open(pwFile) as f:
lines=f.readlines()
username=lines[0].strip()
password=lines[1].strip()
print(" -- found a valid username/password")
except:
print(" -- password lookup FAILED.")
username=TK_askPassword("FTP LOGIN","enter FTP username")
password=TK_askPassword("FTP LOGIN","enter password for %s"%username)
if not username or not password:
print(" !! failed getting login info. aborting FTP effort.")
return
print(" username:",username)
print(" password:","*"*(len(password)))
print(" -- logging in to FTP ...")
try:
ftp = ftplib.FTP("swharden.com")
ftp.login(username, password)
if folder:
ftp.cwd(folder)
return ftp
except:
print(" !! login failure !!")
return False
|
[
"return",
"an",
"FTP",
"object",
"after",
"logging",
"in",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/common.py#L798-L829
|
[
"def",
"ftp_login",
"(",
"folder",
"=",
"None",
")",
":",
"pwDir",
"=",
"os",
".",
"path",
".",
"realpath",
"(",
"__file__",
")",
"for",
"i",
"in",
"range",
"(",
"3",
")",
":",
"pwDir",
"=",
"os",
".",
"path",
".",
"dirname",
"(",
"pwDir",
")",
"pwFile",
"=",
"os",
".",
"path",
".",
"join",
"(",
"pwDir",
",",
"\"passwd.txt\"",
")",
"print",
"(",
"\" -- looking for login information in:\\n [%s]\"",
"%",
"pwFile",
")",
"try",
":",
"with",
"open",
"(",
"pwFile",
")",
"as",
"f",
":",
"lines",
"=",
"f",
".",
"readlines",
"(",
")",
"username",
"=",
"lines",
"[",
"0",
"]",
".",
"strip",
"(",
")",
"password",
"=",
"lines",
"[",
"1",
"]",
".",
"strip",
"(",
")",
"print",
"(",
"\" -- found a valid username/password\"",
")",
"except",
":",
"print",
"(",
"\" -- password lookup FAILED.\"",
")",
"username",
"=",
"TK_askPassword",
"(",
"\"FTP LOGIN\"",
",",
"\"enter FTP username\"",
")",
"password",
"=",
"TK_askPassword",
"(",
"\"FTP LOGIN\"",
",",
"\"enter password for %s\"",
"%",
"username",
")",
"if",
"not",
"username",
"or",
"not",
"password",
":",
"print",
"(",
"\" !! failed getting login info. aborting FTP effort.\"",
")",
"return",
"print",
"(",
"\" username:\"",
",",
"username",
")",
"print",
"(",
"\" password:\"",
",",
"\"*\"",
"*",
"(",
"len",
"(",
"password",
")",
")",
")",
"print",
"(",
"\" -- logging in to FTP ...\"",
")",
"try",
":",
"ftp",
"=",
"ftplib",
".",
"FTP",
"(",
"\"swharden.com\"",
")",
"ftp",
".",
"login",
"(",
"username",
",",
"password",
")",
"if",
"folder",
":",
"ftp",
".",
"cwd",
"(",
"folder",
")",
"return",
"ftp",
"except",
":",
"print",
"(",
"\" !! login failure !!\"",
")",
"return",
"False"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
ftp_folder_match
|
upload everything from localFolder into the current FTP folder.
|
doc/oldcode/swhlab/core/common.py
|
def ftp_folder_match(ftp,localFolder,deleteStuff=True):
"""upload everything from localFolder into the current FTP folder."""
for fname in glob.glob(localFolder+"/*.*"):
ftp_upload(ftp,fname)
return
|
def ftp_folder_match(ftp,localFolder,deleteStuff=True):
"""upload everything from localFolder into the current FTP folder."""
for fname in glob.glob(localFolder+"/*.*"):
ftp_upload(ftp,fname)
return
|
[
"upload",
"everything",
"from",
"localFolder",
"into",
"the",
"current",
"FTP",
"folder",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/common.py#L831-L835
|
[
"def",
"ftp_folder_match",
"(",
"ftp",
",",
"localFolder",
",",
"deleteStuff",
"=",
"True",
")",
":",
"for",
"fname",
"in",
"glob",
".",
"glob",
"(",
"localFolder",
"+",
"\"/*.*\"",
")",
":",
"ftp_upload",
"(",
"ftp",
",",
"fname",
")",
"return"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
version_upload
|
Only scott should do this. Upload new version to site.
|
doc/oldcode/swhlab/core/common.py
|
def version_upload(fname,username="nibjb"):
"""Only scott should do this. Upload new version to site."""
print("popping up pasword window...")
password=TK_askPassword("FTP LOGIN","enter password for %s"%username)
if not password:
return
print("username:",username)
print("password:","*"*(len(password)))
print("connecting...")
ftp = ftplib.FTP("swharden.com")
ftp.login(username, password)
print("successful login!")
ftp.cwd("/software/swhlab/versions") #IMMEDIATELY GO HERE!!!
print("uploading",os.path.basename(fname))
ftp.storbinary("STOR " + os.path.basename(fname), open(fname, "rb"), 1024) #for binary files
print("disconnecting...")
ftp.quit()
|
def version_upload(fname,username="nibjb"):
"""Only scott should do this. Upload new version to site."""
print("popping up pasword window...")
password=TK_askPassword("FTP LOGIN","enter password for %s"%username)
if not password:
return
print("username:",username)
print("password:","*"*(len(password)))
print("connecting...")
ftp = ftplib.FTP("swharden.com")
ftp.login(username, password)
print("successful login!")
ftp.cwd("/software/swhlab/versions") #IMMEDIATELY GO HERE!!!
print("uploading",os.path.basename(fname))
ftp.storbinary("STOR " + os.path.basename(fname), open(fname, "rb"), 1024) #for binary files
print("disconnecting...")
ftp.quit()
|
[
"Only",
"scott",
"should",
"do",
"this",
".",
"Upload",
"new",
"version",
"to",
"site",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/common.py#L845-L861
|
[
"def",
"version_upload",
"(",
"fname",
",",
"username",
"=",
"\"nibjb\"",
")",
":",
"print",
"(",
"\"popping up pasword window...\"",
")",
"password",
"=",
"TK_askPassword",
"(",
"\"FTP LOGIN\"",
",",
"\"enter password for %s\"",
"%",
"username",
")",
"if",
"not",
"password",
":",
"return",
"print",
"(",
"\"username:\"",
",",
"username",
")",
"print",
"(",
"\"password:\"",
",",
"\"*\"",
"*",
"(",
"len",
"(",
"password",
")",
")",
")",
"print",
"(",
"\"connecting...\"",
")",
"ftp",
"=",
"ftplib",
".",
"FTP",
"(",
"\"swharden.com\"",
")",
"ftp",
".",
"login",
"(",
"username",
",",
"password",
")",
"print",
"(",
"\"successful login!\"",
")",
"ftp",
".",
"cwd",
"(",
"\"/software/swhlab/versions\"",
")",
"#IMMEDIATELY GO HERE!!!",
"print",
"(",
"\"uploading\"",
",",
"os",
".",
"path",
".",
"basename",
"(",
"fname",
")",
")",
"ftp",
".",
"storbinary",
"(",
"\"STOR \"",
"+",
"os",
".",
"path",
".",
"basename",
"(",
"fname",
")",
",",
"open",
"(",
"fname",
",",
"\"rb\"",
")",
",",
"1024",
")",
"#for binary files",
"print",
"(",
"\"disconnecting...\"",
")",
"ftp",
".",
"quit",
"(",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
TK_askPassword
|
use the GUI to ask for a string.
|
doc/oldcode/swhlab/core/common.py
|
def TK_askPassword(title="input",msg="type here:"):
"""use the GUI to ask for a string."""
root = tkinter.Tk()
root.withdraw() #hide tk window
root.attributes("-topmost", True) #always on top
root.lift() #bring to top
value=tkinter.simpledialog.askstring(title,msg)
root.destroy()
return value
|
def TK_askPassword(title="input",msg="type here:"):
"""use the GUI to ask for a string."""
root = tkinter.Tk()
root.withdraw() #hide tk window
root.attributes("-topmost", True) #always on top
root.lift() #bring to top
value=tkinter.simpledialog.askstring(title,msg)
root.destroy()
return value
|
[
"use",
"the",
"GUI",
"to",
"ask",
"for",
"a",
"string",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/common.py#L865-L873
|
[
"def",
"TK_askPassword",
"(",
"title",
"=",
"\"input\"",
",",
"msg",
"=",
"\"type here:\"",
")",
":",
"root",
"=",
"tkinter",
".",
"Tk",
"(",
")",
"root",
".",
"withdraw",
"(",
")",
"#hide tk window",
"root",
".",
"attributes",
"(",
"\"-topmost\"",
",",
"True",
")",
"#always on top",
"root",
".",
"lift",
"(",
")",
"#bring to top",
"value",
"=",
"tkinter",
".",
"simpledialog",
".",
"askstring",
"(",
"title",
",",
"msg",
")",
"root",
".",
"destroy",
"(",
")",
"return",
"value"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
TK_message
|
use the GUI to pop up a message.
|
doc/oldcode/swhlab/core/common.py
|
def TK_message(title,msg):
"""use the GUI to pop up a message."""
root = tkinter.Tk()
root.withdraw() #hide tk window
root.attributes("-topmost", True) #always on top
root.lift() #bring to top
tkinter.messagebox.showwarning(title, msg)
root.destroy()
|
def TK_message(title,msg):
"""use the GUI to pop up a message."""
root = tkinter.Tk()
root.withdraw() #hide tk window
root.attributes("-topmost", True) #always on top
root.lift() #bring to top
tkinter.messagebox.showwarning(title, msg)
root.destroy()
|
[
"use",
"the",
"GUI",
"to",
"pop",
"up",
"a",
"message",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/common.py#L875-L882
|
[
"def",
"TK_message",
"(",
"title",
",",
"msg",
")",
":",
"root",
"=",
"tkinter",
".",
"Tk",
"(",
")",
"root",
".",
"withdraw",
"(",
")",
"#hide tk window",
"root",
".",
"attributes",
"(",
"\"-topmost\"",
",",
"True",
")",
"#always on top",
"root",
".",
"lift",
"(",
")",
"#bring to top",
"tkinter",
".",
"messagebox",
".",
"showwarning",
"(",
"title",
",",
"msg",
")",
"root",
".",
"destroy",
"(",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
TK_ask
|
use the GUI to ask YES or NO.
|
doc/oldcode/swhlab/core/common.py
|
def TK_ask(title,msg):
"""use the GUI to ask YES or NO."""
root = tkinter.Tk()
root.attributes("-topmost", True) #always on top
root.withdraw() #hide tk window
result=tkinter.messagebox.askyesno(title,msg)
root.destroy()
return result
|
def TK_ask(title,msg):
"""use the GUI to ask YES or NO."""
root = tkinter.Tk()
root.attributes("-topmost", True) #always on top
root.withdraw() #hide tk window
result=tkinter.messagebox.askyesno(title,msg)
root.destroy()
return result
|
[
"use",
"the",
"GUI",
"to",
"ask",
"YES",
"or",
"NO",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/common.py#L884-L891
|
[
"def",
"TK_ask",
"(",
"title",
",",
"msg",
")",
":",
"root",
"=",
"tkinter",
".",
"Tk",
"(",
")",
"root",
".",
"attributes",
"(",
"\"-topmost\"",
",",
"True",
")",
"#always on top",
"root",
".",
"withdraw",
"(",
")",
"#hide tk window",
"result",
"=",
"tkinter",
".",
"messagebox",
".",
"askyesno",
"(",
"title",
",",
"msg",
")",
"root",
".",
"destroy",
"(",
")",
"return",
"result"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
image_convert
|
Convert weird TIF files into web-friendly versions.
Auto contrast is applied (saturating lower and upper 0.1%).
make saveAs True to save as .TIF.png
make saveAs False and it won't save at all
make saveAs "someFile.jpg" to save it as a different path/format
|
doc/oldcode/swhlab/core/common.py
|
def image_convert(fname,saveAs=True,showToo=False):
"""
Convert weird TIF files into web-friendly versions.
Auto contrast is applied (saturating lower and upper 0.1%).
make saveAs True to save as .TIF.png
make saveAs False and it won't save at all
make saveAs "someFile.jpg" to save it as a different path/format
"""
# load the image
#im = Image.open(fname) #PIL can't handle 12-bit TIFs well
im=scipy.ndimage.imread(fname) #scipy does better with it
im=np.array(im,dtype=float) # now it's a numpy array
# do all image enhancement here
cutoffLow=np.percentile(im,.01)
cutoffHigh=np.percentile(im,99.99)
im[np.where(im<cutoffLow)]=cutoffLow
im[np.where(im>cutoffHigh)]=cutoffHigh
# IMAGE FORMATTING
im-=np.min(im) #auto contrast
im/=np.max(im) #normalize
im*=255 #stretch contrast (8-bit)
im = Image.fromarray(im)
# IMAGE DRAWING
msg="Filename: %s\n"%os.path.basename(fname)
timestamp = datetime.datetime.fromtimestamp(os.path.getctime(fname))
msg+="Created: %s\n"%timestamp.strftime('%Y-%m-%d %H:%M:%S')
d = ImageDraw.Draw(im)
fnt = ImageFont.truetype("arial.ttf", 20)
d.text((6,6),msg,font=fnt,fill=0)
d.text((4,4),msg,font=fnt,fill=255)
if showToo:
im.show()
if saveAs is False:
return
if saveAs is True:
saveAs=fname+".png"
im.convert('RGB').save(saveAs)
|
def image_convert(fname,saveAs=True,showToo=False):
"""
Convert weird TIF files into web-friendly versions.
Auto contrast is applied (saturating lower and upper 0.1%).
make saveAs True to save as .TIF.png
make saveAs False and it won't save at all
make saveAs "someFile.jpg" to save it as a different path/format
"""
# load the image
#im = Image.open(fname) #PIL can't handle 12-bit TIFs well
im=scipy.ndimage.imread(fname) #scipy does better with it
im=np.array(im,dtype=float) # now it's a numpy array
# do all image enhancement here
cutoffLow=np.percentile(im,.01)
cutoffHigh=np.percentile(im,99.99)
im[np.where(im<cutoffLow)]=cutoffLow
im[np.where(im>cutoffHigh)]=cutoffHigh
# IMAGE FORMATTING
im-=np.min(im) #auto contrast
im/=np.max(im) #normalize
im*=255 #stretch contrast (8-bit)
im = Image.fromarray(im)
# IMAGE DRAWING
msg="Filename: %s\n"%os.path.basename(fname)
timestamp = datetime.datetime.fromtimestamp(os.path.getctime(fname))
msg+="Created: %s\n"%timestamp.strftime('%Y-%m-%d %H:%M:%S')
d = ImageDraw.Draw(im)
fnt = ImageFont.truetype("arial.ttf", 20)
d.text((6,6),msg,font=fnt,fill=0)
d.text((4,4),msg,font=fnt,fill=255)
if showToo:
im.show()
if saveAs is False:
return
if saveAs is True:
saveAs=fname+".png"
im.convert('RGB').save(saveAs)
|
[
"Convert",
"weird",
"TIF",
"files",
"into",
"web",
"-",
"friendly",
"versions",
".",
"Auto",
"contrast",
"is",
"applied",
"(",
"saturating",
"lower",
"and",
"upper",
"0",
".",
"1%",
")",
".",
"make",
"saveAs",
"True",
"to",
"save",
"as",
".",
"TIF",
".",
"png",
"make",
"saveAs",
"False",
"and",
"it",
"won",
"t",
"save",
"at",
"all",
"make",
"saveAs",
"someFile",
".",
"jpg",
"to",
"save",
"it",
"as",
"a",
"different",
"path",
"/",
"format"
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/common.py#L896-L937
|
[
"def",
"image_convert",
"(",
"fname",
",",
"saveAs",
"=",
"True",
",",
"showToo",
"=",
"False",
")",
":",
"# load the image",
"#im = Image.open(fname) #PIL can't handle 12-bit TIFs well",
"im",
"=",
"scipy",
".",
"ndimage",
".",
"imread",
"(",
"fname",
")",
"#scipy does better with it",
"im",
"=",
"np",
".",
"array",
"(",
"im",
",",
"dtype",
"=",
"float",
")",
"# now it's a numpy array",
"# do all image enhancement here",
"cutoffLow",
"=",
"np",
".",
"percentile",
"(",
"im",
",",
".01",
")",
"cutoffHigh",
"=",
"np",
".",
"percentile",
"(",
"im",
",",
"99.99",
")",
"im",
"[",
"np",
".",
"where",
"(",
"im",
"<",
"cutoffLow",
")",
"]",
"=",
"cutoffLow",
"im",
"[",
"np",
".",
"where",
"(",
"im",
">",
"cutoffHigh",
")",
"]",
"=",
"cutoffHigh",
"# IMAGE FORMATTING",
"im",
"-=",
"np",
".",
"min",
"(",
"im",
")",
"#auto contrast",
"im",
"/=",
"np",
".",
"max",
"(",
"im",
")",
"#normalize",
"im",
"*=",
"255",
"#stretch contrast (8-bit)",
"im",
"=",
"Image",
".",
"fromarray",
"(",
"im",
")",
"# IMAGE DRAWING",
"msg",
"=",
"\"Filename: %s\\n\"",
"%",
"os",
".",
"path",
".",
"basename",
"(",
"fname",
")",
"timestamp",
"=",
"datetime",
".",
"datetime",
".",
"fromtimestamp",
"(",
"os",
".",
"path",
".",
"getctime",
"(",
"fname",
")",
")",
"msg",
"+=",
"\"Created: %s\\n\"",
"%",
"timestamp",
".",
"strftime",
"(",
"'%Y-%m-%d %H:%M:%S'",
")",
"d",
"=",
"ImageDraw",
".",
"Draw",
"(",
"im",
")",
"fnt",
"=",
"ImageFont",
".",
"truetype",
"(",
"\"arial.ttf\"",
",",
"20",
")",
"d",
".",
"text",
"(",
"(",
"6",
",",
"6",
")",
",",
"msg",
",",
"font",
"=",
"fnt",
",",
"fill",
"=",
"0",
")",
"d",
".",
"text",
"(",
"(",
"4",
",",
"4",
")",
",",
"msg",
",",
"font",
"=",
"fnt",
",",
"fill",
"=",
"255",
")",
"if",
"showToo",
":",
"im",
".",
"show",
"(",
")",
"if",
"saveAs",
"is",
"False",
":",
"return",
"if",
"saveAs",
"is",
"True",
":",
"saveAs",
"=",
"fname",
"+",
"\".png\"",
"im",
".",
"convert",
"(",
"'RGB'",
")",
".",
"save",
"(",
"saveAs",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
processArgs
|
check out the arguments and figure out what to do.
|
swhlab/command.py
|
def processArgs():
"""check out the arguments and figure out what to do."""
if len(sys.argv)<2:
print("\n\nERROR:")
print("this script requires arguments!")
print('try "python command.py info"')
return
if sys.argv[1]=='info':
print("import paths:\n ","\n ".join(sys.path))
print()
print("python version:",sys.version)
print("SWHLab path:",__file__)
print("SWHLab version:",swhlab.__version__)
return
if sys.argv[1]=='glanceFolder':
abfFolder=swhlab.common.gui_getFolder()
if not abfFolder or not os.path.isdir(abfFolder):
print("bad path")
return
fnames=sorted(glob.glob(abfFolder+"/*.abf"))
outFolder=tempfile.gettempdir()+"/swhlab/"
if os.path.exists(outFolder):
shutil.rmtree(outFolder)
os.mkdir(outFolder)
outFile=outFolder+"/index.html"
out='<html><body>'
out+='<h2>%s</h2>'%abfFolder
for i,fname in enumerate(fnames):
print("\n\n### PROCESSING %d of %d"%(i,len(fnames)))
saveAs=os.path.join(os.path.dirname(outFolder),os.path.basename(fname))+".png"
out+='<br><br><br><code>%s</code><br>'%os.path.abspath(fname)
out+='<a href="%s"><img src="%s"></a><br>'%(saveAs,saveAs)
swhlab.analysis.glance.processAbf(fname,saveAs)
out+='</body></html>'
with open(outFile,'w') as f:
f.write(out)
webbrowser.open_new_tab(outFile)
return
print("\n\nERROR:\nI'm not sure how to process these arguments!")
print(sys.argv)
|
def processArgs():
"""check out the arguments and figure out what to do."""
if len(sys.argv)<2:
print("\n\nERROR:")
print("this script requires arguments!")
print('try "python command.py info"')
return
if sys.argv[1]=='info':
print("import paths:\n ","\n ".join(sys.path))
print()
print("python version:",sys.version)
print("SWHLab path:",__file__)
print("SWHLab version:",swhlab.__version__)
return
if sys.argv[1]=='glanceFolder':
abfFolder=swhlab.common.gui_getFolder()
if not abfFolder or not os.path.isdir(abfFolder):
print("bad path")
return
fnames=sorted(glob.glob(abfFolder+"/*.abf"))
outFolder=tempfile.gettempdir()+"/swhlab/"
if os.path.exists(outFolder):
shutil.rmtree(outFolder)
os.mkdir(outFolder)
outFile=outFolder+"/index.html"
out='<html><body>'
out+='<h2>%s</h2>'%abfFolder
for i,fname in enumerate(fnames):
print("\n\n### PROCESSING %d of %d"%(i,len(fnames)))
saveAs=os.path.join(os.path.dirname(outFolder),os.path.basename(fname))+".png"
out+='<br><br><br><code>%s</code><br>'%os.path.abspath(fname)
out+='<a href="%s"><img src="%s"></a><br>'%(saveAs,saveAs)
swhlab.analysis.glance.processAbf(fname,saveAs)
out+='</body></html>'
with open(outFile,'w') as f:
f.write(out)
webbrowser.open_new_tab(outFile)
return
print("\n\nERROR:\nI'm not sure how to process these arguments!")
print(sys.argv)
|
[
"check",
"out",
"the",
"arguments",
"and",
"figure",
"out",
"what",
"to",
"do",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/command.py#L23-L64
|
[
"def",
"processArgs",
"(",
")",
":",
"if",
"len",
"(",
"sys",
".",
"argv",
")",
"<",
"2",
":",
"print",
"(",
"\"\\n\\nERROR:\"",
")",
"print",
"(",
"\"this script requires arguments!\"",
")",
"print",
"(",
"'try \"python command.py info\"'",
")",
"return",
"if",
"sys",
".",
"argv",
"[",
"1",
"]",
"==",
"'info'",
":",
"print",
"(",
"\"import paths:\\n \"",
",",
"\"\\n \"",
".",
"join",
"(",
"sys",
".",
"path",
")",
")",
"print",
"(",
")",
"print",
"(",
"\"python version:\"",
",",
"sys",
".",
"version",
")",
"print",
"(",
"\"SWHLab path:\"",
",",
"__file__",
")",
"print",
"(",
"\"SWHLab version:\"",
",",
"swhlab",
".",
"__version__",
")",
"return",
"if",
"sys",
".",
"argv",
"[",
"1",
"]",
"==",
"'glanceFolder'",
":",
"abfFolder",
"=",
"swhlab",
".",
"common",
".",
"gui_getFolder",
"(",
")",
"if",
"not",
"abfFolder",
"or",
"not",
"os",
".",
"path",
".",
"isdir",
"(",
"abfFolder",
")",
":",
"print",
"(",
"\"bad path\"",
")",
"return",
"fnames",
"=",
"sorted",
"(",
"glob",
".",
"glob",
"(",
"abfFolder",
"+",
"\"/*.abf\"",
")",
")",
"outFolder",
"=",
"tempfile",
".",
"gettempdir",
"(",
")",
"+",
"\"/swhlab/\"",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"outFolder",
")",
":",
"shutil",
".",
"rmtree",
"(",
"outFolder",
")",
"os",
".",
"mkdir",
"(",
"outFolder",
")",
"outFile",
"=",
"outFolder",
"+",
"\"/index.html\"",
"out",
"=",
"'<html><body>'",
"out",
"+=",
"'<h2>%s</h2>'",
"%",
"abfFolder",
"for",
"i",
",",
"fname",
"in",
"enumerate",
"(",
"fnames",
")",
":",
"print",
"(",
"\"\\n\\n### PROCESSING %d of %d\"",
"%",
"(",
"i",
",",
"len",
"(",
"fnames",
")",
")",
")",
"saveAs",
"=",
"os",
".",
"path",
".",
"join",
"(",
"os",
".",
"path",
".",
"dirname",
"(",
"outFolder",
")",
",",
"os",
".",
"path",
".",
"basename",
"(",
"fname",
")",
")",
"+",
"\".png\"",
"out",
"+=",
"'<br><br><br><code>%s</code><br>'",
"%",
"os",
".",
"path",
".",
"abspath",
"(",
"fname",
")",
"out",
"+=",
"'<a href=\"%s\"><img src=\"%s\"></a><br>'",
"%",
"(",
"saveAs",
",",
"saveAs",
")",
"swhlab",
".",
"analysis",
".",
"glance",
".",
"processAbf",
"(",
"fname",
",",
"saveAs",
")",
"out",
"+=",
"'</body></html>'",
"with",
"open",
"(",
"outFile",
",",
"'w'",
")",
"as",
"f",
":",
"f",
".",
"write",
"(",
"out",
")",
"webbrowser",
".",
"open_new_tab",
"(",
"outFile",
")",
"return",
"print",
"(",
"\"\\n\\nERROR:\\nI'm not sure how to process these arguments!\"",
")",
"print",
"(",
"sys",
".",
"argv",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
detect
|
An AP will be detected by a upslope that exceeds 50V/s. Analyzed too.
if type(sweep) is int, graph int(sweep)
if sweep==None, process all sweeps sweep.
|
doc/oldcode/swhlab/core/ap.py
|
def detect(abf,sweep=None,threshold_upslope=50,dT=.1,saveToo=True):
"""
An AP will be detected by a upslope that exceeds 50V/s. Analyzed too.
if type(sweep) is int, graph int(sweep)
if sweep==None, process all sweeps sweep.
"""
if type(sweep) is int:
sweeps=[sweep]
else:
sweeps=list(range(abf.sweeps))
timeStart=time.clock()
abf.APs=[None]*abf.sweeps
abf.SAP=[None]*abf.sweeps
for sweep in sweeps:
abf.setSweep(sweep)
Y=abf.dataY
dI = int(dT/1000*abf.rate) #dI is dT/rate
dY = (Y[dI:]-Y[:-dI])*(abf.rate/1000/dI) #now in V/S
Is = cm.where_cross(dY,threshold_upslope) #found every putative AP (I units)
abf.APs[sweep]=[]
for i in range(len(Is)): #for each putative AP
try:
AP=analyzeAP(Y,dY,Is[i],abf.rate) #try to characterize it
if AP:
AP["sweep"]=sweep
AP["expI"]=sweep*abf.sweepInterval*abf.rate*+AP["sweepI"]
AP["expT"]=sweep*abf.sweepInterval+AP["sweepT"]
AP["freq"]=np.nan #default
if len(abf.APs[sweep]):
AP["freq"]=1/(AP["expT"]-abf.APs[sweep][-1]["expT"])
if AP["freq"] is np.nan or AP["freq"]<500: #at 500Hz, assume you have a duplicate AP
abf.APs[sweep].append(AP)
except:
print(" -- AP %d of %d excluded from analysis..."%(i+1,len(Is)))
#print("!!! AP CRASH !!!")
#print(traceback.format_exc())
analyzeAPgroup(abf) #now that APs are known, get grouping stats
abf.APs=cm.matrixfromDicts(abf.APs)
abf.SAP=cm.matrixfromDicts(abf.SAP)
print(" -- analyzed %d APs in %.02f ms"%(len(cm.dictFlat(abf.APs)),(time.clock()-timeStart)*1000))
if saveToo:
abf.saveThing(abf.APs,"APs")
abf.saveThing(abf.SAP,"SAP")
|
def detect(abf,sweep=None,threshold_upslope=50,dT=.1,saveToo=True):
"""
An AP will be detected by a upslope that exceeds 50V/s. Analyzed too.
if type(sweep) is int, graph int(sweep)
if sweep==None, process all sweeps sweep.
"""
if type(sweep) is int:
sweeps=[sweep]
else:
sweeps=list(range(abf.sweeps))
timeStart=time.clock()
abf.APs=[None]*abf.sweeps
abf.SAP=[None]*abf.sweeps
for sweep in sweeps:
abf.setSweep(sweep)
Y=abf.dataY
dI = int(dT/1000*abf.rate) #dI is dT/rate
dY = (Y[dI:]-Y[:-dI])*(abf.rate/1000/dI) #now in V/S
Is = cm.where_cross(dY,threshold_upslope) #found every putative AP (I units)
abf.APs[sweep]=[]
for i in range(len(Is)): #for each putative AP
try:
AP=analyzeAP(Y,dY,Is[i],abf.rate) #try to characterize it
if AP:
AP["sweep"]=sweep
AP["expI"]=sweep*abf.sweepInterval*abf.rate*+AP["sweepI"]
AP["expT"]=sweep*abf.sweepInterval+AP["sweepT"]
AP["freq"]=np.nan #default
if len(abf.APs[sweep]):
AP["freq"]=1/(AP["expT"]-abf.APs[sweep][-1]["expT"])
if AP["freq"] is np.nan or AP["freq"]<500: #at 500Hz, assume you have a duplicate AP
abf.APs[sweep].append(AP)
except:
print(" -- AP %d of %d excluded from analysis..."%(i+1,len(Is)))
#print("!!! AP CRASH !!!")
#print(traceback.format_exc())
analyzeAPgroup(abf) #now that APs are known, get grouping stats
abf.APs=cm.matrixfromDicts(abf.APs)
abf.SAP=cm.matrixfromDicts(abf.SAP)
print(" -- analyzed %d APs in %.02f ms"%(len(cm.dictFlat(abf.APs)),(time.clock()-timeStart)*1000))
if saveToo:
abf.saveThing(abf.APs,"APs")
abf.saveThing(abf.SAP,"SAP")
|
[
"An",
"AP",
"will",
"be",
"detected",
"by",
"a",
"upslope",
"that",
"exceeds",
"50V",
"/",
"s",
".",
"Analyzed",
"too",
".",
"if",
"type",
"(",
"sweep",
")",
"is",
"int",
"graph",
"int",
"(",
"sweep",
")",
"if",
"sweep",
"==",
"None",
"process",
"all",
"sweeps",
"sweep",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/ap.py#L36-L78
|
[
"def",
"detect",
"(",
"abf",
",",
"sweep",
"=",
"None",
",",
"threshold_upslope",
"=",
"50",
",",
"dT",
"=",
".1",
",",
"saveToo",
"=",
"True",
")",
":",
"if",
"type",
"(",
"sweep",
")",
"is",
"int",
":",
"sweeps",
"=",
"[",
"sweep",
"]",
"else",
":",
"sweeps",
"=",
"list",
"(",
"range",
"(",
"abf",
".",
"sweeps",
")",
")",
"timeStart",
"=",
"time",
".",
"clock",
"(",
")",
"abf",
".",
"APs",
"=",
"[",
"None",
"]",
"*",
"abf",
".",
"sweeps",
"abf",
".",
"SAP",
"=",
"[",
"None",
"]",
"*",
"abf",
".",
"sweeps",
"for",
"sweep",
"in",
"sweeps",
":",
"abf",
".",
"setSweep",
"(",
"sweep",
")",
"Y",
"=",
"abf",
".",
"dataY",
"dI",
"=",
"int",
"(",
"dT",
"/",
"1000",
"*",
"abf",
".",
"rate",
")",
"#dI is dT/rate",
"dY",
"=",
"(",
"Y",
"[",
"dI",
":",
"]",
"-",
"Y",
"[",
":",
"-",
"dI",
"]",
")",
"*",
"(",
"abf",
".",
"rate",
"/",
"1000",
"/",
"dI",
")",
"#now in V/S",
"Is",
"=",
"cm",
".",
"where_cross",
"(",
"dY",
",",
"threshold_upslope",
")",
"#found every putative AP (I units)",
"abf",
".",
"APs",
"[",
"sweep",
"]",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"Is",
")",
")",
":",
"#for each putative AP",
"try",
":",
"AP",
"=",
"analyzeAP",
"(",
"Y",
",",
"dY",
",",
"Is",
"[",
"i",
"]",
",",
"abf",
".",
"rate",
")",
"#try to characterize it",
"if",
"AP",
":",
"AP",
"[",
"\"sweep\"",
"]",
"=",
"sweep",
"AP",
"[",
"\"expI\"",
"]",
"=",
"sweep",
"*",
"abf",
".",
"sweepInterval",
"*",
"abf",
".",
"rate",
"*",
"+",
"AP",
"[",
"\"sweepI\"",
"]",
"AP",
"[",
"\"expT\"",
"]",
"=",
"sweep",
"*",
"abf",
".",
"sweepInterval",
"+",
"AP",
"[",
"\"sweepT\"",
"]",
"AP",
"[",
"\"freq\"",
"]",
"=",
"np",
".",
"nan",
"#default",
"if",
"len",
"(",
"abf",
".",
"APs",
"[",
"sweep",
"]",
")",
":",
"AP",
"[",
"\"freq\"",
"]",
"=",
"1",
"/",
"(",
"AP",
"[",
"\"expT\"",
"]",
"-",
"abf",
".",
"APs",
"[",
"sweep",
"]",
"[",
"-",
"1",
"]",
"[",
"\"expT\"",
"]",
")",
"if",
"AP",
"[",
"\"freq\"",
"]",
"is",
"np",
".",
"nan",
"or",
"AP",
"[",
"\"freq\"",
"]",
"<",
"500",
":",
"#at 500Hz, assume you have a duplicate AP",
"abf",
".",
"APs",
"[",
"sweep",
"]",
".",
"append",
"(",
"AP",
")",
"except",
":",
"print",
"(",
"\" -- AP %d of %d excluded from analysis...\"",
"%",
"(",
"i",
"+",
"1",
",",
"len",
"(",
"Is",
")",
")",
")",
"#print(\"!!! AP CRASH !!!\")",
"#print(traceback.format_exc())",
"analyzeAPgroup",
"(",
"abf",
")",
"#now that APs are known, get grouping stats",
"abf",
".",
"APs",
"=",
"cm",
".",
"matrixfromDicts",
"(",
"abf",
".",
"APs",
")",
"abf",
".",
"SAP",
"=",
"cm",
".",
"matrixfromDicts",
"(",
"abf",
".",
"SAP",
")",
"print",
"(",
"\" -- analyzed %d APs in %.02f ms\"",
"%",
"(",
"len",
"(",
"cm",
".",
"dictFlat",
"(",
"abf",
".",
"APs",
")",
")",
",",
"(",
"time",
".",
"clock",
"(",
")",
"-",
"timeStart",
")",
"*",
"1000",
")",
")",
"if",
"saveToo",
":",
"abf",
".",
"saveThing",
"(",
"abf",
".",
"APs",
",",
"\"APs\"",
")",
"abf",
".",
"saveThing",
"(",
"abf",
".",
"SAP",
",",
"\"SAP\"",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
analyzeAPgroup
|
On the current (setSweep()) sweep, calculate things like accomodation.
Only call directly just for demonstrating how it works by making a graph.
Or call this if you want really custom T1 and T2 (multiple per sweep)
This is called by default with default T1 and T2.
Manually call it again for custom.
|
doc/oldcode/swhlab/core/ap.py
|
def analyzeAPgroup(abf=exampleABF,T1=None,T2=None,plotToo=False):
"""
On the current (setSweep()) sweep, calculate things like accomodation.
Only call directly just for demonstrating how it works by making a graph.
Or call this if you want really custom T1 and T2 (multiple per sweep)
This is called by default with default T1 and T2.
Manually call it again for custom.
"""
if T1 is None or T2 is None:
if len(abf.protoSeqX)>2:
T1=abf.protoSeqX[1]/abf.rate
T2=abf.protoSeqX[2]/abf.rate
else:
T1=0
T2=abf.sweepLength
s={} #sweep dictionary to contain our stas
s["sweep"]=abf.currentSweep
s["commandI"]=abf.protoSeqY[1]
APs=[]
for key in ['freqAvg','freqBin']:
s[key]=0
for AP in abf.APs[abf.currentSweep]:
if T1<AP["sweepT"]<T2:
APs.append(AP)
s["nAPs"]=len(APs) #number of APs in the bin period (T1-T2)
apTimes=cm.dictVals(APs,'sweepT')
if len(APs)>1: #some measurements require multiple APs, like accomodation
s["centerBinTime"]=np.average(apTimes)-T1 #average time of APs in the bin
s["centerBinFrac"]=s["centerBinTime"]/(T2-T1)*100 #fractional average of APs in bin (steady = .5)
s["centerTime"]=np.average(apTimes)-APs[0]["sweepT"] #time of average AP WRT first AP (not bin)
s["centerFrac"]=s["centerTime"]/(APs[-1]["sweepT"]-APs[0]["sweepT"])*100 #WRT first/last AP
s["msToFirst"]=(APs[0]["sweepT"]-T1)*1000 #ms to first AP (from T1)
s["freqFirst1"]=APs[1]['freq'] #inst frequency of first AP
s["freqFirst5"]=cm.dictAvg(APs[1:6],'freq')[0] #inst frequency of first AP
s["freqLast"]=APs[-1]['freq'] #inst frequency of last AP
s["freqAvg"]=cm.dictAvg(APs,'freq')[0] #average inst frequency of all aps
s["freqBin"]=len(APs)/(T2-T1) #frequency of APs in the bin (T1-T2)
s["freqSteady25"]=cm.dictAvg(APs[-int(len(APs)*.25):],'freq')[0] # average freq of the last 25% of APs
s["accom1Avg"]=s["freqFirst1"]/s["freqAvg"] #accomodation (first II / average)
s["accom1Steady25"]=s["freqFirst1"]/s["freqSteady25"] #accomodation (first II / steady state)
s["accom5Avg"]=s["freqFirst5"]/s["freqAvg"] #accomodation from average 5 first
s["accom5Steady25"]=s["freqFirst5"]/s["freqSteady25"] #accomodation from average 5 first
s["freqCV"]=cm.dictAvg(APs,'freq')[1]/cm.dictAvg(APs,'freq')[0] #coefficient of variation (Hz)
s["T1"]=T1
s["T2"]=T2
abf.SAP[abf.currentSweep]=s
|
def analyzeAPgroup(abf=exampleABF,T1=None,T2=None,plotToo=False):
"""
On the current (setSweep()) sweep, calculate things like accomodation.
Only call directly just for demonstrating how it works by making a graph.
Or call this if you want really custom T1 and T2 (multiple per sweep)
This is called by default with default T1 and T2.
Manually call it again for custom.
"""
if T1 is None or T2 is None:
if len(abf.protoSeqX)>2:
T1=abf.protoSeqX[1]/abf.rate
T2=abf.protoSeqX[2]/abf.rate
else:
T1=0
T2=abf.sweepLength
s={} #sweep dictionary to contain our stas
s["sweep"]=abf.currentSweep
s["commandI"]=abf.protoSeqY[1]
APs=[]
for key in ['freqAvg','freqBin']:
s[key]=0
for AP in abf.APs[abf.currentSweep]:
if T1<AP["sweepT"]<T2:
APs.append(AP)
s["nAPs"]=len(APs) #number of APs in the bin period (T1-T2)
apTimes=cm.dictVals(APs,'sweepT')
if len(APs)>1: #some measurements require multiple APs, like accomodation
s["centerBinTime"]=np.average(apTimes)-T1 #average time of APs in the bin
s["centerBinFrac"]=s["centerBinTime"]/(T2-T1)*100 #fractional average of APs in bin (steady = .5)
s["centerTime"]=np.average(apTimes)-APs[0]["sweepT"] #time of average AP WRT first AP (not bin)
s["centerFrac"]=s["centerTime"]/(APs[-1]["sweepT"]-APs[0]["sweepT"])*100 #WRT first/last AP
s["msToFirst"]=(APs[0]["sweepT"]-T1)*1000 #ms to first AP (from T1)
s["freqFirst1"]=APs[1]['freq'] #inst frequency of first AP
s["freqFirst5"]=cm.dictAvg(APs[1:6],'freq')[0] #inst frequency of first AP
s["freqLast"]=APs[-1]['freq'] #inst frequency of last AP
s["freqAvg"]=cm.dictAvg(APs,'freq')[0] #average inst frequency of all aps
s["freqBin"]=len(APs)/(T2-T1) #frequency of APs in the bin (T1-T2)
s["freqSteady25"]=cm.dictAvg(APs[-int(len(APs)*.25):],'freq')[0] # average freq of the last 25% of APs
s["accom1Avg"]=s["freqFirst1"]/s["freqAvg"] #accomodation (first II / average)
s["accom1Steady25"]=s["freqFirst1"]/s["freqSteady25"] #accomodation (first II / steady state)
s["accom5Avg"]=s["freqFirst5"]/s["freqAvg"] #accomodation from average 5 first
s["accom5Steady25"]=s["freqFirst5"]/s["freqSteady25"] #accomodation from average 5 first
s["freqCV"]=cm.dictAvg(APs,'freq')[1]/cm.dictAvg(APs,'freq')[0] #coefficient of variation (Hz)
s["T1"]=T1
s["T2"]=T2
abf.SAP[abf.currentSweep]=s
|
[
"On",
"the",
"current",
"(",
"setSweep",
"()",
")",
"sweep",
"calculate",
"things",
"like",
"accomodation",
".",
"Only",
"call",
"directly",
"just",
"for",
"demonstrating",
"how",
"it",
"works",
"by",
"making",
"a",
"graph",
".",
"Or",
"call",
"this",
"if",
"you",
"want",
"really",
"custom",
"T1",
"and",
"T2",
"(",
"multiple",
"per",
"sweep",
")",
"This",
"is",
"called",
"by",
"default",
"with",
"default",
"T1",
"and",
"T2",
".",
"Manually",
"call",
"it",
"again",
"for",
"custom",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/ap.py#L80-L128
|
[
"def",
"analyzeAPgroup",
"(",
"abf",
"=",
"exampleABF",
",",
"T1",
"=",
"None",
",",
"T2",
"=",
"None",
",",
"plotToo",
"=",
"False",
")",
":",
"if",
"T1",
"is",
"None",
"or",
"T2",
"is",
"None",
":",
"if",
"len",
"(",
"abf",
".",
"protoSeqX",
")",
">",
"2",
":",
"T1",
"=",
"abf",
".",
"protoSeqX",
"[",
"1",
"]",
"/",
"abf",
".",
"rate",
"T2",
"=",
"abf",
".",
"protoSeqX",
"[",
"2",
"]",
"/",
"abf",
".",
"rate",
"else",
":",
"T1",
"=",
"0",
"T2",
"=",
"abf",
".",
"sweepLength",
"s",
"=",
"{",
"}",
"#sweep dictionary to contain our stas",
"s",
"[",
"\"sweep\"",
"]",
"=",
"abf",
".",
"currentSweep",
"s",
"[",
"\"commandI\"",
"]",
"=",
"abf",
".",
"protoSeqY",
"[",
"1",
"]",
"APs",
"=",
"[",
"]",
"for",
"key",
"in",
"[",
"'freqAvg'",
",",
"'freqBin'",
"]",
":",
"s",
"[",
"key",
"]",
"=",
"0",
"for",
"AP",
"in",
"abf",
".",
"APs",
"[",
"abf",
".",
"currentSweep",
"]",
":",
"if",
"T1",
"<",
"AP",
"[",
"\"sweepT\"",
"]",
"<",
"T2",
":",
"APs",
".",
"append",
"(",
"AP",
")",
"s",
"[",
"\"nAPs\"",
"]",
"=",
"len",
"(",
"APs",
")",
"#number of APs in the bin period (T1-T2)",
"apTimes",
"=",
"cm",
".",
"dictVals",
"(",
"APs",
",",
"'sweepT'",
")",
"if",
"len",
"(",
"APs",
")",
">",
"1",
":",
"#some measurements require multiple APs, like accomodation",
"s",
"[",
"\"centerBinTime\"",
"]",
"=",
"np",
".",
"average",
"(",
"apTimes",
")",
"-",
"T1",
"#average time of APs in the bin",
"s",
"[",
"\"centerBinFrac\"",
"]",
"=",
"s",
"[",
"\"centerBinTime\"",
"]",
"/",
"(",
"T2",
"-",
"T1",
")",
"*",
"100",
"#fractional average of APs in bin (steady = .5)",
"s",
"[",
"\"centerTime\"",
"]",
"=",
"np",
".",
"average",
"(",
"apTimes",
")",
"-",
"APs",
"[",
"0",
"]",
"[",
"\"sweepT\"",
"]",
"#time of average AP WRT first AP (not bin)",
"s",
"[",
"\"centerFrac\"",
"]",
"=",
"s",
"[",
"\"centerTime\"",
"]",
"/",
"(",
"APs",
"[",
"-",
"1",
"]",
"[",
"\"sweepT\"",
"]",
"-",
"APs",
"[",
"0",
"]",
"[",
"\"sweepT\"",
"]",
")",
"*",
"100",
"#WRT first/last AP",
"s",
"[",
"\"msToFirst\"",
"]",
"=",
"(",
"APs",
"[",
"0",
"]",
"[",
"\"sweepT\"",
"]",
"-",
"T1",
")",
"*",
"1000",
"#ms to first AP (from T1)",
"s",
"[",
"\"freqFirst1\"",
"]",
"=",
"APs",
"[",
"1",
"]",
"[",
"'freq'",
"]",
"#inst frequency of first AP",
"s",
"[",
"\"freqFirst5\"",
"]",
"=",
"cm",
".",
"dictAvg",
"(",
"APs",
"[",
"1",
":",
"6",
"]",
",",
"'freq'",
")",
"[",
"0",
"]",
"#inst frequency of first AP",
"s",
"[",
"\"freqLast\"",
"]",
"=",
"APs",
"[",
"-",
"1",
"]",
"[",
"'freq'",
"]",
"#inst frequency of last AP",
"s",
"[",
"\"freqAvg\"",
"]",
"=",
"cm",
".",
"dictAvg",
"(",
"APs",
",",
"'freq'",
")",
"[",
"0",
"]",
"#average inst frequency of all aps",
"s",
"[",
"\"freqBin\"",
"]",
"=",
"len",
"(",
"APs",
")",
"/",
"(",
"T2",
"-",
"T1",
")",
"#frequency of APs in the bin (T1-T2)",
"s",
"[",
"\"freqSteady25\"",
"]",
"=",
"cm",
".",
"dictAvg",
"(",
"APs",
"[",
"-",
"int",
"(",
"len",
"(",
"APs",
")",
"*",
".25",
")",
":",
"]",
",",
"'freq'",
")",
"[",
"0",
"]",
"# average freq of the last 25% of APs",
"s",
"[",
"\"accom1Avg\"",
"]",
"=",
"s",
"[",
"\"freqFirst1\"",
"]",
"/",
"s",
"[",
"\"freqAvg\"",
"]",
"#accomodation (first II / average)",
"s",
"[",
"\"accom1Steady25\"",
"]",
"=",
"s",
"[",
"\"freqFirst1\"",
"]",
"/",
"s",
"[",
"\"freqSteady25\"",
"]",
"#accomodation (first II / steady state)",
"s",
"[",
"\"accom5Avg\"",
"]",
"=",
"s",
"[",
"\"freqFirst5\"",
"]",
"/",
"s",
"[",
"\"freqAvg\"",
"]",
"#accomodation from average 5 first",
"s",
"[",
"\"accom5Steady25\"",
"]",
"=",
"s",
"[",
"\"freqFirst5\"",
"]",
"/",
"s",
"[",
"\"freqSteady25\"",
"]",
"#accomodation from average 5 first",
"s",
"[",
"\"freqCV\"",
"]",
"=",
"cm",
".",
"dictAvg",
"(",
"APs",
",",
"'freq'",
")",
"[",
"1",
"]",
"/",
"cm",
".",
"dictAvg",
"(",
"APs",
",",
"'freq'",
")",
"[",
"0",
"]",
"#coefficient of variation (Hz)",
"s",
"[",
"\"T1\"",
"]",
"=",
"T1",
"s",
"[",
"\"T2\"",
"]",
"=",
"T2",
"abf",
".",
"SAP",
"[",
"abf",
".",
"currentSweep",
"]",
"=",
"s"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
check_AP_group
|
after running detect() and abf.SAP is populated, this checks it.
|
doc/oldcode/swhlab/core/ap.py
|
def check_AP_group(abf=exampleABF,sweep=0):
"""
after running detect() and abf.SAP is populated, this checks it.
"""
abf.setSweep(sweep)
swhlab.plot.new(abf,title="sweep %d (%d pA)"%(abf.currentSweep,abf.protoSeqY[1]))
swhlab.plot.sweep(abf)
SAP=cm.matrixToDicts(abf.SAP[sweep])
if "T1" in SAP.keys():
T1=SAP["T1"]
T2=SAP["T2"]
pylab.axvspan(T1/abf.rate,T2/abf.rate,color='r',alpha=.1)
else:
T1=0
T2=abf.sweepLength
swhlab.plot.annotate(abf)
pylab.tight_layout()
pylab.subplots_adjust(right=0.6)
pylab.annotate(cm.msgDict(SAP),(.71,.95),ha='left',va='top',
weight='bold',family='monospace',
xycoords='figure fraction',size=12,color='g')
pylab.axis([T1-.05,T2+.05,None,None])
|
def check_AP_group(abf=exampleABF,sweep=0):
"""
after running detect() and abf.SAP is populated, this checks it.
"""
abf.setSweep(sweep)
swhlab.plot.new(abf,title="sweep %d (%d pA)"%(abf.currentSweep,abf.protoSeqY[1]))
swhlab.plot.sweep(abf)
SAP=cm.matrixToDicts(abf.SAP[sweep])
if "T1" in SAP.keys():
T1=SAP["T1"]
T2=SAP["T2"]
pylab.axvspan(T1/abf.rate,T2/abf.rate,color='r',alpha=.1)
else:
T1=0
T2=abf.sweepLength
swhlab.plot.annotate(abf)
pylab.tight_layout()
pylab.subplots_adjust(right=0.6)
pylab.annotate(cm.msgDict(SAP),(.71,.95),ha='left',va='top',
weight='bold',family='monospace',
xycoords='figure fraction',size=12,color='g')
pylab.axis([T1-.05,T2+.05,None,None])
|
[
"after",
"running",
"detect",
"()",
"and",
"abf",
".",
"SAP",
"is",
"populated",
"this",
"checks",
"it",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/ap.py#L130-L151
|
[
"def",
"check_AP_group",
"(",
"abf",
"=",
"exampleABF",
",",
"sweep",
"=",
"0",
")",
":",
"abf",
".",
"setSweep",
"(",
"sweep",
")",
"swhlab",
".",
"plot",
".",
"new",
"(",
"abf",
",",
"title",
"=",
"\"sweep %d (%d pA)\"",
"%",
"(",
"abf",
".",
"currentSweep",
",",
"abf",
".",
"protoSeqY",
"[",
"1",
"]",
")",
")",
"swhlab",
".",
"plot",
".",
"sweep",
"(",
"abf",
")",
"SAP",
"=",
"cm",
".",
"matrixToDicts",
"(",
"abf",
".",
"SAP",
"[",
"sweep",
"]",
")",
"if",
"\"T1\"",
"in",
"SAP",
".",
"keys",
"(",
")",
":",
"T1",
"=",
"SAP",
"[",
"\"T1\"",
"]",
"T2",
"=",
"SAP",
"[",
"\"T2\"",
"]",
"pylab",
".",
"axvspan",
"(",
"T1",
"/",
"abf",
".",
"rate",
",",
"T2",
"/",
"abf",
".",
"rate",
",",
"color",
"=",
"'r'",
",",
"alpha",
"=",
".1",
")",
"else",
":",
"T1",
"=",
"0",
"T2",
"=",
"abf",
".",
"sweepLength",
"swhlab",
".",
"plot",
".",
"annotate",
"(",
"abf",
")",
"pylab",
".",
"tight_layout",
"(",
")",
"pylab",
".",
"subplots_adjust",
"(",
"right",
"=",
"0.6",
")",
"pylab",
".",
"annotate",
"(",
"cm",
".",
"msgDict",
"(",
"SAP",
")",
",",
"(",
".71",
",",
".95",
")",
",",
"ha",
"=",
"'left'",
",",
"va",
"=",
"'top'",
",",
"weight",
"=",
"'bold'",
",",
"family",
"=",
"'monospace'",
",",
"xycoords",
"=",
"'figure fraction'",
",",
"size",
"=",
"12",
",",
"color",
"=",
"'g'",
")",
"pylab",
".",
"axis",
"(",
"[",
"T1",
"-",
".05",
",",
"T2",
"+",
".05",
",",
"None",
",",
"None",
"]",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
analyzeAP
|
given a sweep and a time point, return the AP array for that AP.
APs will be centered in time by their maximum upslope.
|
doc/oldcode/swhlab/core/ap.py
|
def analyzeAP(Y,dY,I,rate,verbose=False):
"""
given a sweep and a time point, return the AP array for that AP.
APs will be centered in time by their maximum upslope.
"""
Ims = int(rate/1000) #Is per MS
IsToLook=5*Ims #TODO: clarify this, ms until downslope is over
upslope=np.max(dY[I:I+IsToLook]) #maximum rise velocity
upslopeI=np.where(dY[I:I+IsToLook]==upslope)[0][0]+I
I=upslopeI #center sweep at the upslope
downslope=np.min(dY[I:I+IsToLook]) #maximum fall velocity
downslopeI=np.where(dY[I:I+IsToLook]==downslope)[0][0]+I
peak=np.max(Y[I:I+IsToLook]) #find peak value (mV)
peakI=np.where(Y[I:I+IsToLook]==peak)[0][0]+I #find peak I
thresholdI=I-np.where(dY[I:I+IsToLook:--1]<10)[0] #detect <10V/S
if not len(thresholdI):
return False
thresholdI=thresholdI[0]
threshold=Y[thresholdI] # mV where >10mV/S
height=peak-threshold # height (mV) from threshold to peak
halfwidthPoint=np.average((threshold,peak))
halfwidth=np.where(Y[I-IsToLook:I+IsToLook]>halfwidthPoint)[0]
if not len(halfwidth):
return False #doesn't look like a real AP
halfwidthI1=halfwidth[0]+I-IsToLook
halfwidthI2=halfwidth[-1]+I-IsToLook
if Y[halfwidthI1-1]>halfwidthPoint or Y[halfwidthI2+1]>halfwidthPoint:
return False #doesn't look like a real AP
halfwidth=len(halfwidth)/rate*1000 #now in MS
riseTime=(peakI-thresholdI)*1000/rate # time (ms) from threshold to peak
IsToLook=100*Ims #TODO: max prediction until AHP reaches nadir
AHPchunk=np.diff(Y[downslopeI:downslopeI+IsToLook]) #first inflection
AHPI=np.where(AHPchunk>0)[0]
if len(AHPI)==0:
AHPI=np.nan
else:
AHPI=AHPI[0]+downslopeI
AHPchunk=Y[AHPI:AHPI+IsToLook]
if max(AHPchunk)>threshold: #if another AP is coming, cut it out
AHPchunk=AHPchunk[:np.where(AHPchunk>threshold)[0][0]]
if len(AHPchunk):
AHP=np.nanmin(AHPchunk)
AHPI=np.where(AHPchunk==AHP)[0][0]+AHPI
AHPheight=threshold-AHP # AHP magnitude from threshold (mV)
IsToLook=500*Ims #TODO: max prediction until AHP reaches threshold
AHPreturn=np.average((AHP,threshold)) #half of threshold
AHPreturnI=np.where(Y[AHPI:AHPI+IsToLook]>AHPreturn)[0]
if len(AHPreturnI): #not having a clean decay won't cause AP to crash
AHPreturnI=AHPreturnI[0]+AHPI
AHPrisetime=(AHPreturnI-AHPI)*2/rate*1000 #predicted return time (ms)
AHPupslope=AHPheight/AHPrisetime #mV/ms = V/S
AHPreturnFullI=(AHPreturnI-AHPI)*2+AHPI
else: #make them nan so you can do averages later
AHPreturnI,AHPrisetime,AHPupslope=np.nan,np.nan,np.nan
downslope=np.nan
#fasttime (10V/S to 10V/S) #TODO:
#dpp (deriv peak to peak) #TODO:
sweepI,sweepT=I,I/rate # clean up variable names
del IsToLook,I, Y, dY, Ims, AHPchunk, verbose #delete what we don't need
return locals()
|
def analyzeAP(Y,dY,I,rate,verbose=False):
"""
given a sweep and a time point, return the AP array for that AP.
APs will be centered in time by their maximum upslope.
"""
Ims = int(rate/1000) #Is per MS
IsToLook=5*Ims #TODO: clarify this, ms until downslope is over
upslope=np.max(dY[I:I+IsToLook]) #maximum rise velocity
upslopeI=np.where(dY[I:I+IsToLook]==upslope)[0][0]+I
I=upslopeI #center sweep at the upslope
downslope=np.min(dY[I:I+IsToLook]) #maximum fall velocity
downslopeI=np.where(dY[I:I+IsToLook]==downslope)[0][0]+I
peak=np.max(Y[I:I+IsToLook]) #find peak value (mV)
peakI=np.where(Y[I:I+IsToLook]==peak)[0][0]+I #find peak I
thresholdI=I-np.where(dY[I:I+IsToLook:--1]<10)[0] #detect <10V/S
if not len(thresholdI):
return False
thresholdI=thresholdI[0]
threshold=Y[thresholdI] # mV where >10mV/S
height=peak-threshold # height (mV) from threshold to peak
halfwidthPoint=np.average((threshold,peak))
halfwidth=np.where(Y[I-IsToLook:I+IsToLook]>halfwidthPoint)[0]
if not len(halfwidth):
return False #doesn't look like a real AP
halfwidthI1=halfwidth[0]+I-IsToLook
halfwidthI2=halfwidth[-1]+I-IsToLook
if Y[halfwidthI1-1]>halfwidthPoint or Y[halfwidthI2+1]>halfwidthPoint:
return False #doesn't look like a real AP
halfwidth=len(halfwidth)/rate*1000 #now in MS
riseTime=(peakI-thresholdI)*1000/rate # time (ms) from threshold to peak
IsToLook=100*Ims #TODO: max prediction until AHP reaches nadir
AHPchunk=np.diff(Y[downslopeI:downslopeI+IsToLook]) #first inflection
AHPI=np.where(AHPchunk>0)[0]
if len(AHPI)==0:
AHPI=np.nan
else:
AHPI=AHPI[0]+downslopeI
AHPchunk=Y[AHPI:AHPI+IsToLook]
if max(AHPchunk)>threshold: #if another AP is coming, cut it out
AHPchunk=AHPchunk[:np.where(AHPchunk>threshold)[0][0]]
if len(AHPchunk):
AHP=np.nanmin(AHPchunk)
AHPI=np.where(AHPchunk==AHP)[0][0]+AHPI
AHPheight=threshold-AHP # AHP magnitude from threshold (mV)
IsToLook=500*Ims #TODO: max prediction until AHP reaches threshold
AHPreturn=np.average((AHP,threshold)) #half of threshold
AHPreturnI=np.where(Y[AHPI:AHPI+IsToLook]>AHPreturn)[0]
if len(AHPreturnI): #not having a clean decay won't cause AP to crash
AHPreturnI=AHPreturnI[0]+AHPI
AHPrisetime=(AHPreturnI-AHPI)*2/rate*1000 #predicted return time (ms)
AHPupslope=AHPheight/AHPrisetime #mV/ms = V/S
AHPreturnFullI=(AHPreturnI-AHPI)*2+AHPI
else: #make them nan so you can do averages later
AHPreturnI,AHPrisetime,AHPupslope=np.nan,np.nan,np.nan
downslope=np.nan
#fasttime (10V/S to 10V/S) #TODO:
#dpp (deriv peak to peak) #TODO:
sweepI,sweepT=I,I/rate # clean up variable names
del IsToLook,I, Y, dY, Ims, AHPchunk, verbose #delete what we don't need
return locals()
|
[
"given",
"a",
"sweep",
"and",
"a",
"time",
"point",
"return",
"the",
"AP",
"array",
"for",
"that",
"AP",
".",
"APs",
"will",
"be",
"centered",
"in",
"time",
"by",
"their",
"maximum",
"upslope",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/ap.py#L153-L215
|
[
"def",
"analyzeAP",
"(",
"Y",
",",
"dY",
",",
"I",
",",
"rate",
",",
"verbose",
"=",
"False",
")",
":",
"Ims",
"=",
"int",
"(",
"rate",
"/",
"1000",
")",
"#Is per MS",
"IsToLook",
"=",
"5",
"*",
"Ims",
"#TODO: clarify this, ms until downslope is over",
"upslope",
"=",
"np",
".",
"max",
"(",
"dY",
"[",
"I",
":",
"I",
"+",
"IsToLook",
"]",
")",
"#maximum rise velocity",
"upslopeI",
"=",
"np",
".",
"where",
"(",
"dY",
"[",
"I",
":",
"I",
"+",
"IsToLook",
"]",
"==",
"upslope",
")",
"[",
"0",
"]",
"[",
"0",
"]",
"+",
"I",
"I",
"=",
"upslopeI",
"#center sweep at the upslope",
"downslope",
"=",
"np",
".",
"min",
"(",
"dY",
"[",
"I",
":",
"I",
"+",
"IsToLook",
"]",
")",
"#maximum fall velocity",
"downslopeI",
"=",
"np",
".",
"where",
"(",
"dY",
"[",
"I",
":",
"I",
"+",
"IsToLook",
"]",
"==",
"downslope",
")",
"[",
"0",
"]",
"[",
"0",
"]",
"+",
"I",
"peak",
"=",
"np",
".",
"max",
"(",
"Y",
"[",
"I",
":",
"I",
"+",
"IsToLook",
"]",
")",
"#find peak value (mV)",
"peakI",
"=",
"np",
".",
"where",
"(",
"Y",
"[",
"I",
":",
"I",
"+",
"IsToLook",
"]",
"==",
"peak",
")",
"[",
"0",
"]",
"[",
"0",
"]",
"+",
"I",
"#find peak I",
"thresholdI",
"=",
"I",
"-",
"np",
".",
"where",
"(",
"dY",
"[",
"I",
":",
"I",
"+",
"IsToLook",
":",
"-",
"-",
"1",
"]",
"<",
"10",
")",
"[",
"0",
"]",
"#detect <10V/S",
"if",
"not",
"len",
"(",
"thresholdI",
")",
":",
"return",
"False",
"thresholdI",
"=",
"thresholdI",
"[",
"0",
"]",
"threshold",
"=",
"Y",
"[",
"thresholdI",
"]",
"# mV where >10mV/S",
"height",
"=",
"peak",
"-",
"threshold",
"# height (mV) from threshold to peak",
"halfwidthPoint",
"=",
"np",
".",
"average",
"(",
"(",
"threshold",
",",
"peak",
")",
")",
"halfwidth",
"=",
"np",
".",
"where",
"(",
"Y",
"[",
"I",
"-",
"IsToLook",
":",
"I",
"+",
"IsToLook",
"]",
">",
"halfwidthPoint",
")",
"[",
"0",
"]",
"if",
"not",
"len",
"(",
"halfwidth",
")",
":",
"return",
"False",
"#doesn't look like a real AP",
"halfwidthI1",
"=",
"halfwidth",
"[",
"0",
"]",
"+",
"I",
"-",
"IsToLook",
"halfwidthI2",
"=",
"halfwidth",
"[",
"-",
"1",
"]",
"+",
"I",
"-",
"IsToLook",
"if",
"Y",
"[",
"halfwidthI1",
"-",
"1",
"]",
">",
"halfwidthPoint",
"or",
"Y",
"[",
"halfwidthI2",
"+",
"1",
"]",
">",
"halfwidthPoint",
":",
"return",
"False",
"#doesn't look like a real AP",
"halfwidth",
"=",
"len",
"(",
"halfwidth",
")",
"/",
"rate",
"*",
"1000",
"#now in MS",
"riseTime",
"=",
"(",
"peakI",
"-",
"thresholdI",
")",
"*",
"1000",
"/",
"rate",
"# time (ms) from threshold to peak",
"IsToLook",
"=",
"100",
"*",
"Ims",
"#TODO: max prediction until AHP reaches nadir",
"AHPchunk",
"=",
"np",
".",
"diff",
"(",
"Y",
"[",
"downslopeI",
":",
"downslopeI",
"+",
"IsToLook",
"]",
")",
"#first inflection",
"AHPI",
"=",
"np",
".",
"where",
"(",
"AHPchunk",
">",
"0",
")",
"[",
"0",
"]",
"if",
"len",
"(",
"AHPI",
")",
"==",
"0",
":",
"AHPI",
"=",
"np",
".",
"nan",
"else",
":",
"AHPI",
"=",
"AHPI",
"[",
"0",
"]",
"+",
"downslopeI",
"AHPchunk",
"=",
"Y",
"[",
"AHPI",
":",
"AHPI",
"+",
"IsToLook",
"]",
"if",
"max",
"(",
"AHPchunk",
")",
">",
"threshold",
":",
"#if another AP is coming, cut it out",
"AHPchunk",
"=",
"AHPchunk",
"[",
":",
"np",
".",
"where",
"(",
"AHPchunk",
">",
"threshold",
")",
"[",
"0",
"]",
"[",
"0",
"]",
"]",
"if",
"len",
"(",
"AHPchunk",
")",
":",
"AHP",
"=",
"np",
".",
"nanmin",
"(",
"AHPchunk",
")",
"AHPI",
"=",
"np",
".",
"where",
"(",
"AHPchunk",
"==",
"AHP",
")",
"[",
"0",
"]",
"[",
"0",
"]",
"+",
"AHPI",
"AHPheight",
"=",
"threshold",
"-",
"AHP",
"# AHP magnitude from threshold (mV)",
"IsToLook",
"=",
"500",
"*",
"Ims",
"#TODO: max prediction until AHP reaches threshold",
"AHPreturn",
"=",
"np",
".",
"average",
"(",
"(",
"AHP",
",",
"threshold",
")",
")",
"#half of threshold",
"AHPreturnI",
"=",
"np",
".",
"where",
"(",
"Y",
"[",
"AHPI",
":",
"AHPI",
"+",
"IsToLook",
"]",
">",
"AHPreturn",
")",
"[",
"0",
"]",
"if",
"len",
"(",
"AHPreturnI",
")",
":",
"#not having a clean decay won't cause AP to crash",
"AHPreturnI",
"=",
"AHPreturnI",
"[",
"0",
"]",
"+",
"AHPI",
"AHPrisetime",
"=",
"(",
"AHPreturnI",
"-",
"AHPI",
")",
"*",
"2",
"/",
"rate",
"*",
"1000",
"#predicted return time (ms)",
"AHPupslope",
"=",
"AHPheight",
"/",
"AHPrisetime",
"#mV/ms = V/S",
"AHPreturnFullI",
"=",
"(",
"AHPreturnI",
"-",
"AHPI",
")",
"*",
"2",
"+",
"AHPI",
"else",
":",
"#make them nan so you can do averages later",
"AHPreturnI",
",",
"AHPrisetime",
",",
"AHPupslope",
"=",
"np",
".",
"nan",
",",
"np",
".",
"nan",
",",
"np",
".",
"nan",
"downslope",
"=",
"np",
".",
"nan",
"#fasttime (10V/S to 10V/S) #TODO:",
"#dpp (deriv peak to peak) #TODO:",
"sweepI",
",",
"sweepT",
"=",
"I",
",",
"I",
"/",
"rate",
"# clean up variable names",
"del",
"IsToLook",
",",
"I",
",",
"Y",
",",
"dY",
",",
"Ims",
",",
"AHPchunk",
",",
"verbose",
"#delete what we don't need",
"return",
"locals",
"(",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
check_sweep
|
Plotting for an eyeball check of AP detection in the given sweep.
|
doc/oldcode/swhlab/core/ap.py
|
def check_sweep(abf,sweep=None,dT=.1):
"""Plotting for an eyeball check of AP detection in the given sweep."""
if abf.APs is None:
APs=[]
else:
APs=cm.matrixToDicts(abf.APs)
if sweep is None or len(sweep)==0: #find the first sweep with >5APs in it
for sweepNum in range(abf.sweeps):
foundInThisSweep=0
for AP in APs:
if AP["sweep"]==sweepNum:
foundInThisSweep+=1
if foundInThisSweep>=5:
break
sweep=sweepNum
abf.setSweep(sweep)
Y=abf.dataY
dI = int(dT/1000*abf.rate) #dI is dT/rate
dY = (Y[dI:]-Y[:-dI])*(abf.rate/1000/dI) #now in V/S
pylab.figure(figsize=(12,6))
ax=pylab.subplot(211)
pylab.title("sweep %d"%abf.currentSweep)
pylab.ylabel("membrane potential (mV)")
pylab.plot(Y,'-',alpha=.8)
for AP in APs:
if not AP["sweep"]==sweep:
continue
pylab.axvline(AP["sweepI"],alpha=.2,color='r')
pylab.plot(AP["peakI"],AP["peak"],'.',alpha=.5,ms=20,color='r')
pylab.plot(AP["thresholdI"],AP["threshold"],'.',alpha=.5,ms=20,color='c')
pylab.plot([AP["AHPI"],AP["AHPreturnI"]],
[AP["AHP"],AP["AHPreturn"]],
'-',alpha=.2,ms=20,color='b',lw=7)
pylab.plot([AP["halfwidthI1"],AP["halfwidthI2"]],
[AP["halfwidthPoint"],AP["halfwidthPoint"]],
'-',lw=5,alpha=.5,color='g')
pylab.subplot(212,sharex=ax)
pylab.ylabel("velocity (V/S)")
pylab.xlabel("data points (%.02f kHz)"%(abf.rate/1000))
pylab.plot(dY,'-',alpha=.8)
pylab.margins(0,.1)
for AP in APs:
if not AP["sweep"]==sweep:
continue
pylab.axvline(AP["sweepI"],alpha=.2,color='r')
pylab.plot(AP["upslopeI"],AP["upslope"],'.',alpha=.5,ms=20,color='g')
pylab.plot(AP["downslopeI"],AP["downslope"],'.',alpha=.5,ms=20,color='g')
pylab.axis([APs[0]["sweepI"]-1000,APs[-1]["sweepI"]+1000,None,None])
|
def check_sweep(abf,sweep=None,dT=.1):
"""Plotting for an eyeball check of AP detection in the given sweep."""
if abf.APs is None:
APs=[]
else:
APs=cm.matrixToDicts(abf.APs)
if sweep is None or len(sweep)==0: #find the first sweep with >5APs in it
for sweepNum in range(abf.sweeps):
foundInThisSweep=0
for AP in APs:
if AP["sweep"]==sweepNum:
foundInThisSweep+=1
if foundInThisSweep>=5:
break
sweep=sweepNum
abf.setSweep(sweep)
Y=abf.dataY
dI = int(dT/1000*abf.rate) #dI is dT/rate
dY = (Y[dI:]-Y[:-dI])*(abf.rate/1000/dI) #now in V/S
pylab.figure(figsize=(12,6))
ax=pylab.subplot(211)
pylab.title("sweep %d"%abf.currentSweep)
pylab.ylabel("membrane potential (mV)")
pylab.plot(Y,'-',alpha=.8)
for AP in APs:
if not AP["sweep"]==sweep:
continue
pylab.axvline(AP["sweepI"],alpha=.2,color='r')
pylab.plot(AP["peakI"],AP["peak"],'.',alpha=.5,ms=20,color='r')
pylab.plot(AP["thresholdI"],AP["threshold"],'.',alpha=.5,ms=20,color='c')
pylab.plot([AP["AHPI"],AP["AHPreturnI"]],
[AP["AHP"],AP["AHPreturn"]],
'-',alpha=.2,ms=20,color='b',lw=7)
pylab.plot([AP["halfwidthI1"],AP["halfwidthI2"]],
[AP["halfwidthPoint"],AP["halfwidthPoint"]],
'-',lw=5,alpha=.5,color='g')
pylab.subplot(212,sharex=ax)
pylab.ylabel("velocity (V/S)")
pylab.xlabel("data points (%.02f kHz)"%(abf.rate/1000))
pylab.plot(dY,'-',alpha=.8)
pylab.margins(0,.1)
for AP in APs:
if not AP["sweep"]==sweep:
continue
pylab.axvline(AP["sweepI"],alpha=.2,color='r')
pylab.plot(AP["upslopeI"],AP["upslope"],'.',alpha=.5,ms=20,color='g')
pylab.plot(AP["downslopeI"],AP["downslope"],'.',alpha=.5,ms=20,color='g')
pylab.axis([APs[0]["sweepI"]-1000,APs[-1]["sweepI"]+1000,None,None])
|
[
"Plotting",
"for",
"an",
"eyeball",
"check",
"of",
"AP",
"detection",
"in",
"the",
"given",
"sweep",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/ap.py#L217-L268
|
[
"def",
"check_sweep",
"(",
"abf",
",",
"sweep",
"=",
"None",
",",
"dT",
"=",
".1",
")",
":",
"if",
"abf",
".",
"APs",
"is",
"None",
":",
"APs",
"=",
"[",
"]",
"else",
":",
"APs",
"=",
"cm",
".",
"matrixToDicts",
"(",
"abf",
".",
"APs",
")",
"if",
"sweep",
"is",
"None",
"or",
"len",
"(",
"sweep",
")",
"==",
"0",
":",
"#find the first sweep with >5APs in it",
"for",
"sweepNum",
"in",
"range",
"(",
"abf",
".",
"sweeps",
")",
":",
"foundInThisSweep",
"=",
"0",
"for",
"AP",
"in",
"APs",
":",
"if",
"AP",
"[",
"\"sweep\"",
"]",
"==",
"sweepNum",
":",
"foundInThisSweep",
"+=",
"1",
"if",
"foundInThisSweep",
">=",
"5",
":",
"break",
"sweep",
"=",
"sweepNum",
"abf",
".",
"setSweep",
"(",
"sweep",
")",
"Y",
"=",
"abf",
".",
"dataY",
"dI",
"=",
"int",
"(",
"dT",
"/",
"1000",
"*",
"abf",
".",
"rate",
")",
"#dI is dT/rate",
"dY",
"=",
"(",
"Y",
"[",
"dI",
":",
"]",
"-",
"Y",
"[",
":",
"-",
"dI",
"]",
")",
"*",
"(",
"abf",
".",
"rate",
"/",
"1000",
"/",
"dI",
")",
"#now in V/S",
"pylab",
".",
"figure",
"(",
"figsize",
"=",
"(",
"12",
",",
"6",
")",
")",
"ax",
"=",
"pylab",
".",
"subplot",
"(",
"211",
")",
"pylab",
".",
"title",
"(",
"\"sweep %d\"",
"%",
"abf",
".",
"currentSweep",
")",
"pylab",
".",
"ylabel",
"(",
"\"membrane potential (mV)\"",
")",
"pylab",
".",
"plot",
"(",
"Y",
",",
"'-'",
",",
"alpha",
"=",
".8",
")",
"for",
"AP",
"in",
"APs",
":",
"if",
"not",
"AP",
"[",
"\"sweep\"",
"]",
"==",
"sweep",
":",
"continue",
"pylab",
".",
"axvline",
"(",
"AP",
"[",
"\"sweepI\"",
"]",
",",
"alpha",
"=",
".2",
",",
"color",
"=",
"'r'",
")",
"pylab",
".",
"plot",
"(",
"AP",
"[",
"\"peakI\"",
"]",
",",
"AP",
"[",
"\"peak\"",
"]",
",",
"'.'",
",",
"alpha",
"=",
".5",
",",
"ms",
"=",
"20",
",",
"color",
"=",
"'r'",
")",
"pylab",
".",
"plot",
"(",
"AP",
"[",
"\"thresholdI\"",
"]",
",",
"AP",
"[",
"\"threshold\"",
"]",
",",
"'.'",
",",
"alpha",
"=",
".5",
",",
"ms",
"=",
"20",
",",
"color",
"=",
"'c'",
")",
"pylab",
".",
"plot",
"(",
"[",
"AP",
"[",
"\"AHPI\"",
"]",
",",
"AP",
"[",
"\"AHPreturnI\"",
"]",
"]",
",",
"[",
"AP",
"[",
"\"AHP\"",
"]",
",",
"AP",
"[",
"\"AHPreturn\"",
"]",
"]",
",",
"'-'",
",",
"alpha",
"=",
".2",
",",
"ms",
"=",
"20",
",",
"color",
"=",
"'b'",
",",
"lw",
"=",
"7",
")",
"pylab",
".",
"plot",
"(",
"[",
"AP",
"[",
"\"halfwidthI1\"",
"]",
",",
"AP",
"[",
"\"halfwidthI2\"",
"]",
"]",
",",
"[",
"AP",
"[",
"\"halfwidthPoint\"",
"]",
",",
"AP",
"[",
"\"halfwidthPoint\"",
"]",
"]",
",",
"'-'",
",",
"lw",
"=",
"5",
",",
"alpha",
"=",
".5",
",",
"color",
"=",
"'g'",
")",
"pylab",
".",
"subplot",
"(",
"212",
",",
"sharex",
"=",
"ax",
")",
"pylab",
".",
"ylabel",
"(",
"\"velocity (V/S)\"",
")",
"pylab",
".",
"xlabel",
"(",
"\"data points (%.02f kHz)\"",
"%",
"(",
"abf",
".",
"rate",
"/",
"1000",
")",
")",
"pylab",
".",
"plot",
"(",
"dY",
",",
"'-'",
",",
"alpha",
"=",
".8",
")",
"pylab",
".",
"margins",
"(",
"0",
",",
".1",
")",
"for",
"AP",
"in",
"APs",
":",
"if",
"not",
"AP",
"[",
"\"sweep\"",
"]",
"==",
"sweep",
":",
"continue",
"pylab",
".",
"axvline",
"(",
"AP",
"[",
"\"sweepI\"",
"]",
",",
"alpha",
"=",
".2",
",",
"color",
"=",
"'r'",
")",
"pylab",
".",
"plot",
"(",
"AP",
"[",
"\"upslopeI\"",
"]",
",",
"AP",
"[",
"\"upslope\"",
"]",
",",
"'.'",
",",
"alpha",
"=",
".5",
",",
"ms",
"=",
"20",
",",
"color",
"=",
"'g'",
")",
"pylab",
".",
"plot",
"(",
"AP",
"[",
"\"downslopeI\"",
"]",
",",
"AP",
"[",
"\"downslope\"",
"]",
",",
"'.'",
",",
"alpha",
"=",
".5",
",",
"ms",
"=",
"20",
",",
"color",
"=",
"'g'",
")",
"pylab",
".",
"axis",
"(",
"[",
"APs",
"[",
"0",
"]",
"[",
"\"sweepI\"",
"]",
"-",
"1000",
",",
"APs",
"[",
"-",
"1",
"]",
"[",
"\"sweepI\"",
"]",
"+",
"1000",
",",
"None",
",",
"None",
"]",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
get_AP_timepoints
|
return list of time points (sec) of all AP events in experiment.
|
doc/oldcode/swhlab/core/ap.py
|
def get_AP_timepoints(abf):
"""return list of time points (sec) of all AP events in experiment."""
col=abf.APs.dtype.names.index("expT")
timePoints=[]
for i in range(len(abf.APs)):
timePoints.append(abf.APs[i][col])
return timePoints
|
def get_AP_timepoints(abf):
"""return list of time points (sec) of all AP events in experiment."""
col=abf.APs.dtype.names.index("expT")
timePoints=[]
for i in range(len(abf.APs)):
timePoints.append(abf.APs[i][col])
return timePoints
|
[
"return",
"list",
"of",
"time",
"points",
"(",
"sec",
")",
"of",
"all",
"AP",
"events",
"in",
"experiment",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/ap.py#L270-L276
|
[
"def",
"get_AP_timepoints",
"(",
"abf",
")",
":",
"col",
"=",
"abf",
".",
"APs",
".",
"dtype",
".",
"names",
".",
"index",
"(",
"\"expT\"",
")",
"timePoints",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"abf",
".",
"APs",
")",
")",
":",
"timePoints",
".",
"append",
"(",
"abf",
".",
"APs",
"[",
"i",
"]",
"[",
"col",
"]",
")",
"return",
"timePoints"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
check_AP_raw
|
X
|
doc/oldcode/swhlab/core/ap.py
|
def check_AP_raw(abf,n=10):
"""X"""
timePoints=get_AP_timepoints(abf)[:n] #first 10
if len(timePoints)==0:
return
swhlab.plot.new(abf,True,title="AP shape (n=%d)"%n,xlabel="ms")
Ys=abf.get_data_around(timePoints,padding=.2)
Xs=(np.arange(len(Ys[0]))-len(Ys[0])/2)*1000/abf.rate
for i in range(1,len(Ys)):
pylab.plot(Xs,Ys[i],alpha=.2,color='b')
pylab.plot(Xs,Ys[0],alpha=.4,color='r',lw=2)
pylab.margins(0,.1)
msg=cm.msgDict(cm.dictFlat(abf.APs)[0],cantEndWith="I")
pylab.subplots_adjust(right=0.7)
pylab.annotate(msg,(.71,.95),ha='left',va='top',
xycoords='figure fraction',family='monospace',size=10)
|
def check_AP_raw(abf,n=10):
"""X"""
timePoints=get_AP_timepoints(abf)[:n] #first 10
if len(timePoints)==0:
return
swhlab.plot.new(abf,True,title="AP shape (n=%d)"%n,xlabel="ms")
Ys=abf.get_data_around(timePoints,padding=.2)
Xs=(np.arange(len(Ys[0]))-len(Ys[0])/2)*1000/abf.rate
for i in range(1,len(Ys)):
pylab.plot(Xs,Ys[i],alpha=.2,color='b')
pylab.plot(Xs,Ys[0],alpha=.4,color='r',lw=2)
pylab.margins(0,.1)
msg=cm.msgDict(cm.dictFlat(abf.APs)[0],cantEndWith="I")
pylab.subplots_adjust(right=0.7)
pylab.annotate(msg,(.71,.95),ha='left',va='top',
xycoords='figure fraction',family='monospace',size=10)
|
[
"X"
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/ap.py#L278-L293
|
[
"def",
"check_AP_raw",
"(",
"abf",
",",
"n",
"=",
"10",
")",
":",
"timePoints",
"=",
"get_AP_timepoints",
"(",
"abf",
")",
"[",
":",
"n",
"]",
"#first 10",
"if",
"len",
"(",
"timePoints",
")",
"==",
"0",
":",
"return",
"swhlab",
".",
"plot",
".",
"new",
"(",
"abf",
",",
"True",
",",
"title",
"=",
"\"AP shape (n=%d)\"",
"%",
"n",
",",
"xlabel",
"=",
"\"ms\"",
")",
"Ys",
"=",
"abf",
".",
"get_data_around",
"(",
"timePoints",
",",
"padding",
"=",
".2",
")",
"Xs",
"=",
"(",
"np",
".",
"arange",
"(",
"len",
"(",
"Ys",
"[",
"0",
"]",
")",
")",
"-",
"len",
"(",
"Ys",
"[",
"0",
"]",
")",
"/",
"2",
")",
"*",
"1000",
"/",
"abf",
".",
"rate",
"for",
"i",
"in",
"range",
"(",
"1",
",",
"len",
"(",
"Ys",
")",
")",
":",
"pylab",
".",
"plot",
"(",
"Xs",
",",
"Ys",
"[",
"i",
"]",
",",
"alpha",
"=",
".2",
",",
"color",
"=",
"'b'",
")",
"pylab",
".",
"plot",
"(",
"Xs",
",",
"Ys",
"[",
"0",
"]",
",",
"alpha",
"=",
".4",
",",
"color",
"=",
"'r'",
",",
"lw",
"=",
"2",
")",
"pylab",
".",
"margins",
"(",
"0",
",",
".1",
")",
"msg",
"=",
"cm",
".",
"msgDict",
"(",
"cm",
".",
"dictFlat",
"(",
"abf",
".",
"APs",
")",
"[",
"0",
"]",
",",
"cantEndWith",
"=",
"\"I\"",
")",
"pylab",
".",
"subplots_adjust",
"(",
"right",
"=",
"0.7",
")",
"pylab",
".",
"annotate",
"(",
"msg",
",",
"(",
".71",
",",
".95",
")",
",",
"ha",
"=",
"'left'",
",",
"va",
"=",
"'top'",
",",
"xycoords",
"=",
"'figure fraction'",
",",
"family",
"=",
"'monospace'",
",",
"size",
"=",
"10",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
check_AP_deriv
|
X
|
doc/oldcode/swhlab/core/ap.py
|
def check_AP_deriv(abf,n=10):
"""X"""
timePoints=get_AP_timepoints(abf)[:10] #first 10
if len(timePoints)==0:
return
swhlab.plot.new(abf,True,title="AP velocity (n=%d)"%n,xlabel="ms",ylabel="V/S")
pylab.axhline(-50,color='r',lw=2,ls="--",alpha=.2)
pylab.axhline(-100,color='r',lw=2,ls="--",alpha=.2)
Ys=abf.get_data_around(timePoints,msDeriv=.1,padding=.005)
Xs=(np.arange(len(Ys[0]))-len(Ys[0])/2)*1000/abf.rate
for i in range(1,len(Ys)):
pylab.plot(Xs,Ys[i],alpha=.2,color='b')
pylab.plot(Xs,Ys[0],alpha=.4,color='r',lw=2)
pylab.margins(0,.1)
|
def check_AP_deriv(abf,n=10):
"""X"""
timePoints=get_AP_timepoints(abf)[:10] #first 10
if len(timePoints)==0:
return
swhlab.plot.new(abf,True,title="AP velocity (n=%d)"%n,xlabel="ms",ylabel="V/S")
pylab.axhline(-50,color='r',lw=2,ls="--",alpha=.2)
pylab.axhline(-100,color='r',lw=2,ls="--",alpha=.2)
Ys=abf.get_data_around(timePoints,msDeriv=.1,padding=.005)
Xs=(np.arange(len(Ys[0]))-len(Ys[0])/2)*1000/abf.rate
for i in range(1,len(Ys)):
pylab.plot(Xs,Ys[i],alpha=.2,color='b')
pylab.plot(Xs,Ys[0],alpha=.4,color='r',lw=2)
pylab.margins(0,.1)
|
[
"X"
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/ap.py#L295-L308
|
[
"def",
"check_AP_deriv",
"(",
"abf",
",",
"n",
"=",
"10",
")",
":",
"timePoints",
"=",
"get_AP_timepoints",
"(",
"abf",
")",
"[",
":",
"10",
"]",
"#first 10",
"if",
"len",
"(",
"timePoints",
")",
"==",
"0",
":",
"return",
"swhlab",
".",
"plot",
".",
"new",
"(",
"abf",
",",
"True",
",",
"title",
"=",
"\"AP velocity (n=%d)\"",
"%",
"n",
",",
"xlabel",
"=",
"\"ms\"",
",",
"ylabel",
"=",
"\"V/S\"",
")",
"pylab",
".",
"axhline",
"(",
"-",
"50",
",",
"color",
"=",
"'r'",
",",
"lw",
"=",
"2",
",",
"ls",
"=",
"\"--\"",
",",
"alpha",
"=",
".2",
")",
"pylab",
".",
"axhline",
"(",
"-",
"100",
",",
"color",
"=",
"'r'",
",",
"lw",
"=",
"2",
",",
"ls",
"=",
"\"--\"",
",",
"alpha",
"=",
".2",
")",
"Ys",
"=",
"abf",
".",
"get_data_around",
"(",
"timePoints",
",",
"msDeriv",
"=",
".1",
",",
"padding",
"=",
".005",
")",
"Xs",
"=",
"(",
"np",
".",
"arange",
"(",
"len",
"(",
"Ys",
"[",
"0",
"]",
")",
")",
"-",
"len",
"(",
"Ys",
"[",
"0",
"]",
")",
"/",
"2",
")",
"*",
"1000",
"/",
"abf",
".",
"rate",
"for",
"i",
"in",
"range",
"(",
"1",
",",
"len",
"(",
"Ys",
")",
")",
":",
"pylab",
".",
"plot",
"(",
"Xs",
",",
"Ys",
"[",
"i",
"]",
",",
"alpha",
"=",
".2",
",",
"color",
"=",
"'b'",
")",
"pylab",
".",
"plot",
"(",
"Xs",
",",
"Ys",
"[",
"0",
"]",
",",
"alpha",
"=",
".4",
",",
"color",
"=",
"'r'",
",",
"lw",
"=",
"2",
")",
"pylab",
".",
"margins",
"(",
"0",
",",
".1",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
check_AP_phase
|
X
|
doc/oldcode/swhlab/core/ap.py
|
def check_AP_phase(abf,n=10):
"""X"""
timePoints=get_AP_timepoints(abf)[:10] #first 10
if len(timePoints)==0:
return
swhlab.plot.new(abf,True,title="AP phase (n=%d)"%n,xlabel="mV",ylabel="V/S")
Ys=abf.get_data_around(timePoints,msDeriv=.1,padding=.005)
Xs=abf.get_data_around(timePoints,padding=.005)
for i in range(1,len(Ys)):
pylab.plot(Xs[i],Ys[i],alpha=.2,color='b')
pylab.plot(Xs[0],Ys[0],alpha=.4,color='r',lw=1)
pylab.margins(.1,.1)
|
def check_AP_phase(abf,n=10):
"""X"""
timePoints=get_AP_timepoints(abf)[:10] #first 10
if len(timePoints)==0:
return
swhlab.plot.new(abf,True,title="AP phase (n=%d)"%n,xlabel="mV",ylabel="V/S")
Ys=abf.get_data_around(timePoints,msDeriv=.1,padding=.005)
Xs=abf.get_data_around(timePoints,padding=.005)
for i in range(1,len(Ys)):
pylab.plot(Xs[i],Ys[i],alpha=.2,color='b')
pylab.plot(Xs[0],Ys[0],alpha=.4,color='r',lw=1)
pylab.margins(.1,.1)
|
[
"X"
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/ap.py#L310-L321
|
[
"def",
"check_AP_phase",
"(",
"abf",
",",
"n",
"=",
"10",
")",
":",
"timePoints",
"=",
"get_AP_timepoints",
"(",
"abf",
")",
"[",
":",
"10",
"]",
"#first 10",
"if",
"len",
"(",
"timePoints",
")",
"==",
"0",
":",
"return",
"swhlab",
".",
"plot",
".",
"new",
"(",
"abf",
",",
"True",
",",
"title",
"=",
"\"AP phase (n=%d)\"",
"%",
"n",
",",
"xlabel",
"=",
"\"mV\"",
",",
"ylabel",
"=",
"\"V/S\"",
")",
"Ys",
"=",
"abf",
".",
"get_data_around",
"(",
"timePoints",
",",
"msDeriv",
"=",
".1",
",",
"padding",
"=",
".005",
")",
"Xs",
"=",
"abf",
".",
"get_data_around",
"(",
"timePoints",
",",
"padding",
"=",
".005",
")",
"for",
"i",
"in",
"range",
"(",
"1",
",",
"len",
"(",
"Ys",
")",
")",
":",
"pylab",
".",
"plot",
"(",
"Xs",
"[",
"i",
"]",
",",
"Ys",
"[",
"i",
"]",
",",
"alpha",
"=",
".2",
",",
"color",
"=",
"'b'",
")",
"pylab",
".",
"plot",
"(",
"Xs",
"[",
"0",
"]",
",",
"Ys",
"[",
"0",
"]",
",",
"alpha",
"=",
".4",
",",
"color",
"=",
"'r'",
",",
"lw",
"=",
"1",
")",
"pylab",
".",
"margins",
"(",
".1",
",",
".1",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
stats_first
|
provide all stats on the first AP.
|
doc/oldcode/swhlab/core/ap.py
|
def stats_first(abf):
"""provide all stats on the first AP."""
msg=""
for sweep in range(abf.sweeps):
for AP in abf.APs[sweep]:
for key in sorted(AP.keys()):
if key[-1] is "I" or key[-2:] in ["I1","I2"]:
continue
msg+="%s = %s\n"%(key,AP[key])
return msg
|
def stats_first(abf):
"""provide all stats on the first AP."""
msg=""
for sweep in range(abf.sweeps):
for AP in abf.APs[sweep]:
for key in sorted(AP.keys()):
if key[-1] is "I" or key[-2:] in ["I1","I2"]:
continue
msg+="%s = %s\n"%(key,AP[key])
return msg
|
[
"provide",
"all",
"stats",
"on",
"the",
"first",
"AP",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/ap.py#L323-L332
|
[
"def",
"stats_first",
"(",
"abf",
")",
":",
"msg",
"=",
"\"\"",
"for",
"sweep",
"in",
"range",
"(",
"abf",
".",
"sweeps",
")",
":",
"for",
"AP",
"in",
"abf",
".",
"APs",
"[",
"sweep",
"]",
":",
"for",
"key",
"in",
"sorted",
"(",
"AP",
".",
"keys",
"(",
")",
")",
":",
"if",
"key",
"[",
"-",
"1",
"]",
"is",
"\"I\"",
"or",
"key",
"[",
"-",
"2",
":",
"]",
"in",
"[",
"\"I1\"",
",",
"\"I2\"",
"]",
":",
"continue",
"msg",
"+=",
"\"%s = %s\\n\"",
"%",
"(",
"key",
",",
"AP",
"[",
"key",
"]",
")",
"return",
"msg"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
get_values
|
returns Xs, Ys (the key), and sweep #s for every AP found.
|
doc/oldcode/swhlab/core/ap.py
|
def get_values(abf,key="freq",continuous=False):
"""returns Xs, Ys (the key), and sweep #s for every AP found."""
Xs,Ys,Ss=[],[],[]
for sweep in range(abf.sweeps):
for AP in cm.matrixToDicts(abf.APs):
if not AP["sweep"]==sweep:
continue
Ys.append(AP[key])
Ss.append(AP["sweep"])
if continuous:
Xs.append(AP["expT"])
else:
Xs.append(AP["sweepT"])
return np.array(Xs),np.array(Ys),np.array(Ss)
|
def get_values(abf,key="freq",continuous=False):
"""returns Xs, Ys (the key), and sweep #s for every AP found."""
Xs,Ys,Ss=[],[],[]
for sweep in range(abf.sweeps):
for AP in cm.matrixToDicts(abf.APs):
if not AP["sweep"]==sweep:
continue
Ys.append(AP[key])
Ss.append(AP["sweep"])
if continuous:
Xs.append(AP["expT"])
else:
Xs.append(AP["sweepT"])
return np.array(Xs),np.array(Ys),np.array(Ss)
|
[
"returns",
"Xs",
"Ys",
"(",
"the",
"key",
")",
"and",
"sweep",
"#s",
"for",
"every",
"AP",
"found",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/ap.py#L334-L348
|
[
"def",
"get_values",
"(",
"abf",
",",
"key",
"=",
"\"freq\"",
",",
"continuous",
"=",
"False",
")",
":",
"Xs",
",",
"Ys",
",",
"Ss",
"=",
"[",
"]",
",",
"[",
"]",
",",
"[",
"]",
"for",
"sweep",
"in",
"range",
"(",
"abf",
".",
"sweeps",
")",
":",
"for",
"AP",
"in",
"cm",
".",
"matrixToDicts",
"(",
"abf",
".",
"APs",
")",
":",
"if",
"not",
"AP",
"[",
"\"sweep\"",
"]",
"==",
"sweep",
":",
"continue",
"Ys",
".",
"append",
"(",
"AP",
"[",
"key",
"]",
")",
"Ss",
".",
"append",
"(",
"AP",
"[",
"\"sweep\"",
"]",
")",
"if",
"continuous",
":",
"Xs",
".",
"append",
"(",
"AP",
"[",
"\"expT\"",
"]",
")",
"else",
":",
"Xs",
".",
"append",
"(",
"AP",
"[",
"\"sweepT\"",
"]",
")",
"return",
"np",
".",
"array",
"(",
"Xs",
")",
",",
"np",
".",
"array",
"(",
"Ys",
")",
",",
"np",
".",
"array",
"(",
"Ss",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
getAvgBySweep
|
return average of a feature divided by sweep.
|
doc/oldcode/swhlab/core/ap.py
|
def getAvgBySweep(abf,feature,T0=None,T1=None):
"""return average of a feature divided by sweep."""
if T1 is None:
T1=abf.sweepLength
if T0 is None:
T0=0
data = [np.empty((0))]*abf.sweeps
for AP in cm.dictFlat(cm.matrixToDicts(abf.APs)):
if T0<AP['sweepT']<T1:
val=AP[feature]
data[int(AP['sweep'])]=np.concatenate((data[int(AP['sweep'])],[val]))
for sweep in range(abf.sweeps):
if len(data[sweep])>1 and np.any(data[sweep]):
data[sweep]=np.nanmean(data[sweep])
elif len(data[sweep])==1:
data[sweep]=data[sweep][0]
else:
data[sweep]=np.nan
return data
|
def getAvgBySweep(abf,feature,T0=None,T1=None):
"""return average of a feature divided by sweep."""
if T1 is None:
T1=abf.sweepLength
if T0 is None:
T0=0
data = [np.empty((0))]*abf.sweeps
for AP in cm.dictFlat(cm.matrixToDicts(abf.APs)):
if T0<AP['sweepT']<T1:
val=AP[feature]
data[int(AP['sweep'])]=np.concatenate((data[int(AP['sweep'])],[val]))
for sweep in range(abf.sweeps):
if len(data[sweep])>1 and np.any(data[sweep]):
data[sweep]=np.nanmean(data[sweep])
elif len(data[sweep])==1:
data[sweep]=data[sweep][0]
else:
data[sweep]=np.nan
return data
|
[
"return",
"average",
"of",
"a",
"feature",
"divided",
"by",
"sweep",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/ap.py#L363-L381
|
[
"def",
"getAvgBySweep",
"(",
"abf",
",",
"feature",
",",
"T0",
"=",
"None",
",",
"T1",
"=",
"None",
")",
":",
"if",
"T1",
"is",
"None",
":",
"T1",
"=",
"abf",
".",
"sweepLength",
"if",
"T0",
"is",
"None",
":",
"T0",
"=",
"0",
"data",
"=",
"[",
"np",
".",
"empty",
"(",
"(",
"0",
")",
")",
"]",
"*",
"abf",
".",
"sweeps",
"for",
"AP",
"in",
"cm",
".",
"dictFlat",
"(",
"cm",
".",
"matrixToDicts",
"(",
"abf",
".",
"APs",
")",
")",
":",
"if",
"T0",
"<",
"AP",
"[",
"'sweepT'",
"]",
"<",
"T1",
":",
"val",
"=",
"AP",
"[",
"feature",
"]",
"data",
"[",
"int",
"(",
"AP",
"[",
"'sweep'",
"]",
")",
"]",
"=",
"np",
".",
"concatenate",
"(",
"(",
"data",
"[",
"int",
"(",
"AP",
"[",
"'sweep'",
"]",
")",
"]",
",",
"[",
"val",
"]",
")",
")",
"for",
"sweep",
"in",
"range",
"(",
"abf",
".",
"sweeps",
")",
":",
"if",
"len",
"(",
"data",
"[",
"sweep",
"]",
")",
">",
"1",
"and",
"np",
".",
"any",
"(",
"data",
"[",
"sweep",
"]",
")",
":",
"data",
"[",
"sweep",
"]",
"=",
"np",
".",
"nanmean",
"(",
"data",
"[",
"sweep",
"]",
")",
"elif",
"len",
"(",
"data",
"[",
"sweep",
"]",
")",
"==",
"1",
":",
"data",
"[",
"sweep",
"]",
"=",
"data",
"[",
"sweep",
"]",
"[",
"0",
"]",
"else",
":",
"data",
"[",
"sweep",
"]",
"=",
"np",
".",
"nan",
"return",
"data"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
readLog
|
return a list of [stamp, project] elements.
|
swhlab/tools/project log/analyze.py
|
def readLog(fname="workdays.csv",onlyAfter=datetime.datetime(year=2017,month=1,day=1)):
"""return a list of [stamp, project] elements."""
with open(fname) as f:
raw=f.read().split("\n")
efforts=[] #date,nickname
for line in raw[1:]:
line=line.strip().split(",")
date=datetime.datetime.strptime(line[0], "%Y-%m-%d")
if onlyAfter and date<onlyAfter:
continue
if len(line)<3:
continue
for project in line[2:]:
project=project.strip()
if len(project):
efforts.append([date,project])
return efforts
|
def readLog(fname="workdays.csv",onlyAfter=datetime.datetime(year=2017,month=1,day=1)):
"""return a list of [stamp, project] elements."""
with open(fname) as f:
raw=f.read().split("\n")
efforts=[] #date,nickname
for line in raw[1:]:
line=line.strip().split(",")
date=datetime.datetime.strptime(line[0], "%Y-%m-%d")
if onlyAfter and date<onlyAfter:
continue
if len(line)<3:
continue
for project in line[2:]:
project=project.strip()
if len(project):
efforts.append([date,project])
return efforts
|
[
"return",
"a",
"list",
"of",
"[",
"stamp",
"project",
"]",
"elements",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/tools/project log/analyze.py#L5-L21
|
[
"def",
"readLog",
"(",
"fname",
"=",
"\"workdays.csv\"",
",",
"onlyAfter",
"=",
"datetime",
".",
"datetime",
"(",
"year",
"=",
"2017",
",",
"month",
"=",
"1",
",",
"day",
"=",
"1",
")",
")",
":",
"with",
"open",
"(",
"fname",
")",
"as",
"f",
":",
"raw",
"=",
"f",
".",
"read",
"(",
")",
".",
"split",
"(",
"\"\\n\"",
")",
"efforts",
"=",
"[",
"]",
"#date,nickname\r",
"for",
"line",
"in",
"raw",
"[",
"1",
":",
"]",
":",
"line",
"=",
"line",
".",
"strip",
"(",
")",
".",
"split",
"(",
"\",\"",
")",
"date",
"=",
"datetime",
".",
"datetime",
".",
"strptime",
"(",
"line",
"[",
"0",
"]",
",",
"\"%Y-%m-%d\"",
")",
"if",
"onlyAfter",
"and",
"date",
"<",
"onlyAfter",
":",
"continue",
"if",
"len",
"(",
"line",
")",
"<",
"3",
":",
"continue",
"for",
"project",
"in",
"line",
"[",
"2",
":",
"]",
":",
"project",
"=",
"project",
".",
"strip",
"(",
")",
"if",
"len",
"(",
"project",
")",
":",
"efforts",
".",
"append",
"(",
"[",
"date",
",",
"project",
"]",
")",
"return",
"efforts"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
waitTillCopied
|
sometimes a huge file takes several seconds to copy over.
This will hang until the file is copied (file size is stable).
|
doc/oldcode/indexing/monitor.py
|
def waitTillCopied(fname):
"""
sometimes a huge file takes several seconds to copy over.
This will hang until the file is copied (file size is stable).
"""
lastSize=0
while True:
thisSize=os.path.getsize(fname)
print("size:",thisSize)
if lastSize==thisSize:
print("size: STABLE")
return
else:
lastSize=thisSize
time.sleep(.1)
|
def waitTillCopied(fname):
"""
sometimes a huge file takes several seconds to copy over.
This will hang until the file is copied (file size is stable).
"""
lastSize=0
while True:
thisSize=os.path.getsize(fname)
print("size:",thisSize)
if lastSize==thisSize:
print("size: STABLE")
return
else:
lastSize=thisSize
time.sleep(.1)
|
[
"sometimes",
"a",
"huge",
"file",
"takes",
"several",
"seconds",
"to",
"copy",
"over",
".",
"This",
"will",
"hang",
"until",
"the",
"file",
"is",
"copied",
"(",
"file",
"size",
"is",
"stable",
")",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/indexing/monitor.py#L12-L26
|
[
"def",
"waitTillCopied",
"(",
"fname",
")",
":",
"lastSize",
"=",
"0",
"while",
"True",
":",
"thisSize",
"=",
"os",
".",
"path",
".",
"getsize",
"(",
"fname",
")",
"print",
"(",
"\"size:\"",
",",
"thisSize",
")",
"if",
"lastSize",
"==",
"thisSize",
":",
"print",
"(",
"\"size: STABLE\"",
")",
"return",
"else",
":",
"lastSize",
"=",
"thisSize",
"time",
".",
"sleep",
"(",
".1",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
lazygo
|
continuously monitor a folder for new abfs and try to analyze them.
This is intended to watch only one folder, but can run multiple copies.
|
doc/oldcode/indexing/monitor.py
|
def lazygo(watchFolder='../abfs/',reAnalyze=False,rebuildSite=False,
keepGoing=True,matching=False):
"""
continuously monitor a folder for new abfs and try to analyze them.
This is intended to watch only one folder, but can run multiple copies.
"""
abfsKnown=[]
while True:
print()
pagesNeeded=[]
for fname in glob.glob(watchFolder+"/*.abf"):
ID=os.path.basename(fname).replace(".abf","")
if not fname in abfsKnown:
if os.path.exists(fname.replace(".abf",".rsv")): #TODO: or something like this
continue
if matching and not matching in fname:
continue
abfsKnown.append(fname)
if os.path.exists(os.path.dirname(fname)+"/swhlab4/"+os.path.basename(fname).replace(".abf","_info.pkl")) and reAnalyze==False:
print("already analyzed",os.path.basename(fname))
if rebuildSite:
pagesNeeded.append(ID)
else:
handleNewABF(fname)
pagesNeeded.append(ID)
if len(pagesNeeded):
print(" -- rebuilding index page")
indexing.genIndex(os.path.dirname(fname),forceIDs=pagesNeeded)
if not keepGoing:
return
for i in range(50):
print('.',end='')
time.sleep(.2)
|
def lazygo(watchFolder='../abfs/',reAnalyze=False,rebuildSite=False,
keepGoing=True,matching=False):
"""
continuously monitor a folder for new abfs and try to analyze them.
This is intended to watch only one folder, but can run multiple copies.
"""
abfsKnown=[]
while True:
print()
pagesNeeded=[]
for fname in glob.glob(watchFolder+"/*.abf"):
ID=os.path.basename(fname).replace(".abf","")
if not fname in abfsKnown:
if os.path.exists(fname.replace(".abf",".rsv")): #TODO: or something like this
continue
if matching and not matching in fname:
continue
abfsKnown.append(fname)
if os.path.exists(os.path.dirname(fname)+"/swhlab4/"+os.path.basename(fname).replace(".abf","_info.pkl")) and reAnalyze==False:
print("already analyzed",os.path.basename(fname))
if rebuildSite:
pagesNeeded.append(ID)
else:
handleNewABF(fname)
pagesNeeded.append(ID)
if len(pagesNeeded):
print(" -- rebuilding index page")
indexing.genIndex(os.path.dirname(fname),forceIDs=pagesNeeded)
if not keepGoing:
return
for i in range(50):
print('.',end='')
time.sleep(.2)
|
[
"continuously",
"monitor",
"a",
"folder",
"for",
"new",
"abfs",
"and",
"try",
"to",
"analyze",
"them",
".",
"This",
"is",
"intended",
"to",
"watch",
"only",
"one",
"folder",
"but",
"can",
"run",
"multiple",
"copies",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/indexing/monitor.py#L33-L66
|
[
"def",
"lazygo",
"(",
"watchFolder",
"=",
"'../abfs/'",
",",
"reAnalyze",
"=",
"False",
",",
"rebuildSite",
"=",
"False",
",",
"keepGoing",
"=",
"True",
",",
"matching",
"=",
"False",
")",
":",
"abfsKnown",
"=",
"[",
"]",
"while",
"True",
":",
"print",
"(",
")",
"pagesNeeded",
"=",
"[",
"]",
"for",
"fname",
"in",
"glob",
".",
"glob",
"(",
"watchFolder",
"+",
"\"/*.abf\"",
")",
":",
"ID",
"=",
"os",
".",
"path",
".",
"basename",
"(",
"fname",
")",
".",
"replace",
"(",
"\".abf\"",
",",
"\"\"",
")",
"if",
"not",
"fname",
"in",
"abfsKnown",
":",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"fname",
".",
"replace",
"(",
"\".abf\"",
",",
"\".rsv\"",
")",
")",
":",
"#TODO: or something like this",
"continue",
"if",
"matching",
"and",
"not",
"matching",
"in",
"fname",
":",
"continue",
"abfsKnown",
".",
"append",
"(",
"fname",
")",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"os",
".",
"path",
".",
"dirname",
"(",
"fname",
")",
"+",
"\"/swhlab4/\"",
"+",
"os",
".",
"path",
".",
"basename",
"(",
"fname",
")",
".",
"replace",
"(",
"\".abf\"",
",",
"\"_info.pkl\"",
")",
")",
"and",
"reAnalyze",
"==",
"False",
":",
"print",
"(",
"\"already analyzed\"",
",",
"os",
".",
"path",
".",
"basename",
"(",
"fname",
")",
")",
"if",
"rebuildSite",
":",
"pagesNeeded",
".",
"append",
"(",
"ID",
")",
"else",
":",
"handleNewABF",
"(",
"fname",
")",
"pagesNeeded",
".",
"append",
"(",
"ID",
")",
"if",
"len",
"(",
"pagesNeeded",
")",
":",
"print",
"(",
"\" -- rebuilding index page\"",
")",
"indexing",
".",
"genIndex",
"(",
"os",
".",
"path",
".",
"dirname",
"(",
"fname",
")",
",",
"forceIDs",
"=",
"pagesNeeded",
")",
"if",
"not",
"keepGoing",
":",
"return",
"for",
"i",
"in",
"range",
"(",
"50",
")",
":",
"print",
"(",
"'.'",
",",
"end",
"=",
"''",
")",
"time",
".",
"sleep",
"(",
".2",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
ABF2.phasicTonic
|
chunkMs should be ~50 ms or greater.
bin sizes must be equal to or multiples of the data resolution.
transients smaller than the expected RMS will be silenced.
|
doc/uses/EPSCs-and-IPSCs/variance method/2016-12-17 02 graphTime.py
|
def phasicTonic(self,m1=None,m2=None,chunkMs=50,quietPercentile=10,
histResolution=.5,plotToo=False,rmsExpected=5):
"""
chunkMs should be ~50 ms or greater.
bin sizes must be equal to or multiples of the data resolution.
transients smaller than the expected RMS will be silenced.
"""
# prepare sectioning values to be used later
m1=0 if m1 is None else m1*self.pointsPerSec
m2=len(abf.sweepY) if m2 is None else m2*self.pointsPerSec
m1,m2=int(m1),int(m2)
# prepare histogram values to be used later
padding=200 # pA or mV of maximum expected deviation
chunkPoints=int(chunkMs*self.pointsPerMs)
histBins=int((padding*2)/histResolution)
# center the data at 0 using peak histogram, not the mean
Y=self.sweepY[m1:m2]
hist,bins=np.histogram(Y,bins=2*padding)
Yoffset=bins[np.where(hist==max(hist))[0][0]]
Y=Y-Yoffset # we don't have to, but PDF math is easier
# calculate all histogram
nChunks=int(len(Y)/chunkPoints)
hist,bins=np.histogram(Y,bins=histBins,range=(-padding,padding))
hist=hist/len(Y) # count as a fraction of total
Xs=bins[1:]
# get baseline data from chunks with smallest variance
chunks=np.reshape(Y[:nChunks*chunkPoints],(nChunks,chunkPoints))
variances=np.var(chunks,axis=1)
percentiles=np.empty(len(variances))
for i,variance in enumerate(variances):
percentiles[i]=sorted(variances).index(variance)/len(variances)*100
blData=chunks[np.where(percentiles<=quietPercentile)[0]].flatten()
# generate the standard curve and pull it to the histogram height
sigma=np.sqrt(np.var(blData))
center=np.average(blData)+histResolution/2
blCurve=mlab.normpdf(Xs,center,sigma)
blCurve=blCurve*max(hist)/max(blCurve)
# determine the phasic current by subtracting-out the baseline
diff=hist-blCurve
# manually zero-out data which we expect to be within the RMS range
ignrCenter=len(Xs)/2
ignrPad=rmsExpected/histResolution
ignr1,ignt2=int(ignrCenter-ignrPad),int(ignrCenter+ignrPad)
diff[ignr1:ignt2]=0
return diff/len(Y)*abf.pointsPerSec
|
def phasicTonic(self,m1=None,m2=None,chunkMs=50,quietPercentile=10,
histResolution=.5,plotToo=False,rmsExpected=5):
"""
chunkMs should be ~50 ms or greater.
bin sizes must be equal to or multiples of the data resolution.
transients smaller than the expected RMS will be silenced.
"""
# prepare sectioning values to be used later
m1=0 if m1 is None else m1*self.pointsPerSec
m2=len(abf.sweepY) if m2 is None else m2*self.pointsPerSec
m1,m2=int(m1),int(m2)
# prepare histogram values to be used later
padding=200 # pA or mV of maximum expected deviation
chunkPoints=int(chunkMs*self.pointsPerMs)
histBins=int((padding*2)/histResolution)
# center the data at 0 using peak histogram, not the mean
Y=self.sweepY[m1:m2]
hist,bins=np.histogram(Y,bins=2*padding)
Yoffset=bins[np.where(hist==max(hist))[0][0]]
Y=Y-Yoffset # we don't have to, but PDF math is easier
# calculate all histogram
nChunks=int(len(Y)/chunkPoints)
hist,bins=np.histogram(Y,bins=histBins,range=(-padding,padding))
hist=hist/len(Y) # count as a fraction of total
Xs=bins[1:]
# get baseline data from chunks with smallest variance
chunks=np.reshape(Y[:nChunks*chunkPoints],(nChunks,chunkPoints))
variances=np.var(chunks,axis=1)
percentiles=np.empty(len(variances))
for i,variance in enumerate(variances):
percentiles[i]=sorted(variances).index(variance)/len(variances)*100
blData=chunks[np.where(percentiles<=quietPercentile)[0]].flatten()
# generate the standard curve and pull it to the histogram height
sigma=np.sqrt(np.var(blData))
center=np.average(blData)+histResolution/2
blCurve=mlab.normpdf(Xs,center,sigma)
blCurve=blCurve*max(hist)/max(blCurve)
# determine the phasic current by subtracting-out the baseline
diff=hist-blCurve
# manually zero-out data which we expect to be within the RMS range
ignrCenter=len(Xs)/2
ignrPad=rmsExpected/histResolution
ignr1,ignt2=int(ignrCenter-ignrPad),int(ignrCenter+ignrPad)
diff[ignr1:ignt2]=0
return diff/len(Y)*abf.pointsPerSec
|
[
"chunkMs",
"should",
"be",
"~50",
"ms",
"or",
"greater",
".",
"bin",
"sizes",
"must",
"be",
"equal",
"to",
"or",
"multiples",
"of",
"the",
"data",
"resolution",
".",
"transients",
"smaller",
"than",
"the",
"expected",
"RMS",
"will",
"be",
"silenced",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/uses/EPSCs-and-IPSCs/variance method/2016-12-17 02 graphTime.py#L12-L64
|
[
"def",
"phasicTonic",
"(",
"self",
",",
"m1",
"=",
"None",
",",
"m2",
"=",
"None",
",",
"chunkMs",
"=",
"50",
",",
"quietPercentile",
"=",
"10",
",",
"histResolution",
"=",
".5",
",",
"plotToo",
"=",
"False",
",",
"rmsExpected",
"=",
"5",
")",
":",
"# prepare sectioning values to be used later",
"m1",
"=",
"0",
"if",
"m1",
"is",
"None",
"else",
"m1",
"*",
"self",
".",
"pointsPerSec",
"m2",
"=",
"len",
"(",
"abf",
".",
"sweepY",
")",
"if",
"m2",
"is",
"None",
"else",
"m2",
"*",
"self",
".",
"pointsPerSec",
"m1",
",",
"m2",
"=",
"int",
"(",
"m1",
")",
",",
"int",
"(",
"m2",
")",
"# prepare histogram values to be used later",
"padding",
"=",
"200",
"# pA or mV of maximum expected deviation",
"chunkPoints",
"=",
"int",
"(",
"chunkMs",
"*",
"self",
".",
"pointsPerMs",
")",
"histBins",
"=",
"int",
"(",
"(",
"padding",
"*",
"2",
")",
"/",
"histResolution",
")",
"# center the data at 0 using peak histogram, not the mean",
"Y",
"=",
"self",
".",
"sweepY",
"[",
"m1",
":",
"m2",
"]",
"hist",
",",
"bins",
"=",
"np",
".",
"histogram",
"(",
"Y",
",",
"bins",
"=",
"2",
"*",
"padding",
")",
"Yoffset",
"=",
"bins",
"[",
"np",
".",
"where",
"(",
"hist",
"==",
"max",
"(",
"hist",
")",
")",
"[",
"0",
"]",
"[",
"0",
"]",
"]",
"Y",
"=",
"Y",
"-",
"Yoffset",
"# we don't have to, but PDF math is easier",
"# calculate all histogram",
"nChunks",
"=",
"int",
"(",
"len",
"(",
"Y",
")",
"/",
"chunkPoints",
")",
"hist",
",",
"bins",
"=",
"np",
".",
"histogram",
"(",
"Y",
",",
"bins",
"=",
"histBins",
",",
"range",
"=",
"(",
"-",
"padding",
",",
"padding",
")",
")",
"hist",
"=",
"hist",
"/",
"len",
"(",
"Y",
")",
"# count as a fraction of total",
"Xs",
"=",
"bins",
"[",
"1",
":",
"]",
"# get baseline data from chunks with smallest variance",
"chunks",
"=",
"np",
".",
"reshape",
"(",
"Y",
"[",
":",
"nChunks",
"*",
"chunkPoints",
"]",
",",
"(",
"nChunks",
",",
"chunkPoints",
")",
")",
"variances",
"=",
"np",
".",
"var",
"(",
"chunks",
",",
"axis",
"=",
"1",
")",
"percentiles",
"=",
"np",
".",
"empty",
"(",
"len",
"(",
"variances",
")",
")",
"for",
"i",
",",
"variance",
"in",
"enumerate",
"(",
"variances",
")",
":",
"percentiles",
"[",
"i",
"]",
"=",
"sorted",
"(",
"variances",
")",
".",
"index",
"(",
"variance",
")",
"/",
"len",
"(",
"variances",
")",
"*",
"100",
"blData",
"=",
"chunks",
"[",
"np",
".",
"where",
"(",
"percentiles",
"<=",
"quietPercentile",
")",
"[",
"0",
"]",
"]",
".",
"flatten",
"(",
")",
"# generate the standard curve and pull it to the histogram height",
"sigma",
"=",
"np",
".",
"sqrt",
"(",
"np",
".",
"var",
"(",
"blData",
")",
")",
"center",
"=",
"np",
".",
"average",
"(",
"blData",
")",
"+",
"histResolution",
"/",
"2",
"blCurve",
"=",
"mlab",
".",
"normpdf",
"(",
"Xs",
",",
"center",
",",
"sigma",
")",
"blCurve",
"=",
"blCurve",
"*",
"max",
"(",
"hist",
")",
"/",
"max",
"(",
"blCurve",
")",
"# determine the phasic current by subtracting-out the baseline",
"diff",
"=",
"hist",
"-",
"blCurve",
"# manually zero-out data which we expect to be within the RMS range",
"ignrCenter",
"=",
"len",
"(",
"Xs",
")",
"/",
"2",
"ignrPad",
"=",
"rmsExpected",
"/",
"histResolution",
"ignr1",
",",
"ignt2",
"=",
"int",
"(",
"ignrCenter",
"-",
"ignrPad",
")",
",",
"int",
"(",
"ignrCenter",
"+",
"ignrPad",
")",
"diff",
"[",
"ignr1",
":",
"ignt2",
"]",
"=",
"0",
"return",
"diff",
"/",
"len",
"(",
"Y",
")",
"*",
"abf",
".",
"pointsPerSec"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
values_above_sweep
|
To make plots like AP frequency over original trace.
dataI=[i] #the i of the sweep
dataY=[1.234] #something like inst freq
|
doc/oldcode/swhlab/core/plot.py
|
def values_above_sweep(abf,dataI,dataY,ylabel="",useFigure=None):
"""
To make plots like AP frequency over original trace.
dataI=[i] #the i of the sweep
dataY=[1.234] #something like inst freq
"""
xOffset = abf.currentSweep*abf.sweepInterval
if not useFigure: #just passing the figure makes it persistant!
pylab.figure(figsize=(8,6))
ax=pylab.subplot(221)
pylab.grid(alpha=.5)
if len(dataI):
pylab.plot(abf.dataX[dataI],dataY,'.',ms=10,alpha=.5,
color=abf.colormap[abf.currentSweep])
pylab.margins(0,.1)
pylab.ylabel(ylabel)
pylab.subplot(223,sharex=ax)
pylab.grid(alpha=.5)
pylab.plot(abf.dataX,abf.dataY,color=abf.colormap[abf.currentSweep],alpha=.5)
pylab.ylabel("raw data (%s)"%abf.units)
ax2=pylab.subplot(222)
pylab.grid(alpha=.5)
if len(dataI):
pylab.plot(abf.dataX[dataI]+xOffset,dataY,'.',ms=10,alpha=.5,
color=abf.colormap[abf.currentSweep])
pylab.margins(0,.1)
pylab.ylabel(ylabel)
pylab.subplot(224,sharex=ax2)
pylab.grid(alpha=.5)
pylab.plot(abf.dataX+xOffset,abf.dataY,color=abf.colormap[abf.currentSweep])
pylab.ylabel("raw data (%s)"%abf.units)
pylab.tight_layout()
|
def values_above_sweep(abf,dataI,dataY,ylabel="",useFigure=None):
"""
To make plots like AP frequency over original trace.
dataI=[i] #the i of the sweep
dataY=[1.234] #something like inst freq
"""
xOffset = abf.currentSweep*abf.sweepInterval
if not useFigure: #just passing the figure makes it persistant!
pylab.figure(figsize=(8,6))
ax=pylab.subplot(221)
pylab.grid(alpha=.5)
if len(dataI):
pylab.plot(abf.dataX[dataI],dataY,'.',ms=10,alpha=.5,
color=abf.colormap[abf.currentSweep])
pylab.margins(0,.1)
pylab.ylabel(ylabel)
pylab.subplot(223,sharex=ax)
pylab.grid(alpha=.5)
pylab.plot(abf.dataX,abf.dataY,color=abf.colormap[abf.currentSweep],alpha=.5)
pylab.ylabel("raw data (%s)"%abf.units)
ax2=pylab.subplot(222)
pylab.grid(alpha=.5)
if len(dataI):
pylab.plot(abf.dataX[dataI]+xOffset,dataY,'.',ms=10,alpha=.5,
color=abf.colormap[abf.currentSweep])
pylab.margins(0,.1)
pylab.ylabel(ylabel)
pylab.subplot(224,sharex=ax2)
pylab.grid(alpha=.5)
pylab.plot(abf.dataX+xOffset,abf.dataY,color=abf.colormap[abf.currentSweep])
pylab.ylabel("raw data (%s)"%abf.units)
pylab.tight_layout()
|
[
"To",
"make",
"plots",
"like",
"AP",
"frequency",
"over",
"original",
"trace",
".",
"dataI",
"=",
"[",
"i",
"]",
"#the",
"i",
"of",
"the",
"sweep",
"dataY",
"=",
"[",
"1",
".",
"234",
"]",
"#something",
"like",
"inst",
"freq"
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/plot.py#L48-L84
|
[
"def",
"values_above_sweep",
"(",
"abf",
",",
"dataI",
",",
"dataY",
",",
"ylabel",
"=",
"\"\"",
",",
"useFigure",
"=",
"None",
")",
":",
"xOffset",
"=",
"abf",
".",
"currentSweep",
"*",
"abf",
".",
"sweepInterval",
"if",
"not",
"useFigure",
":",
"#just passing the figure makes it persistant!",
"pylab",
".",
"figure",
"(",
"figsize",
"=",
"(",
"8",
",",
"6",
")",
")",
"ax",
"=",
"pylab",
".",
"subplot",
"(",
"221",
")",
"pylab",
".",
"grid",
"(",
"alpha",
"=",
".5",
")",
"if",
"len",
"(",
"dataI",
")",
":",
"pylab",
".",
"plot",
"(",
"abf",
".",
"dataX",
"[",
"dataI",
"]",
",",
"dataY",
",",
"'.'",
",",
"ms",
"=",
"10",
",",
"alpha",
"=",
".5",
",",
"color",
"=",
"abf",
".",
"colormap",
"[",
"abf",
".",
"currentSweep",
"]",
")",
"pylab",
".",
"margins",
"(",
"0",
",",
".1",
")",
"pylab",
".",
"ylabel",
"(",
"ylabel",
")",
"pylab",
".",
"subplot",
"(",
"223",
",",
"sharex",
"=",
"ax",
")",
"pylab",
".",
"grid",
"(",
"alpha",
"=",
".5",
")",
"pylab",
".",
"plot",
"(",
"abf",
".",
"dataX",
",",
"abf",
".",
"dataY",
",",
"color",
"=",
"abf",
".",
"colormap",
"[",
"abf",
".",
"currentSweep",
"]",
",",
"alpha",
"=",
".5",
")",
"pylab",
".",
"ylabel",
"(",
"\"raw data (%s)\"",
"%",
"abf",
".",
"units",
")",
"ax2",
"=",
"pylab",
".",
"subplot",
"(",
"222",
")",
"pylab",
".",
"grid",
"(",
"alpha",
"=",
".5",
")",
"if",
"len",
"(",
"dataI",
")",
":",
"pylab",
".",
"plot",
"(",
"abf",
".",
"dataX",
"[",
"dataI",
"]",
"+",
"xOffset",
",",
"dataY",
",",
"'.'",
",",
"ms",
"=",
"10",
",",
"alpha",
"=",
".5",
",",
"color",
"=",
"abf",
".",
"colormap",
"[",
"abf",
".",
"currentSweep",
"]",
")",
"pylab",
".",
"margins",
"(",
"0",
",",
".1",
")",
"pylab",
".",
"ylabel",
"(",
"ylabel",
")",
"pylab",
".",
"subplot",
"(",
"224",
",",
"sharex",
"=",
"ax2",
")",
"pylab",
".",
"grid",
"(",
"alpha",
"=",
".5",
")",
"pylab",
".",
"plot",
"(",
"abf",
".",
"dataX",
"+",
"xOffset",
",",
"abf",
".",
"dataY",
",",
"color",
"=",
"abf",
".",
"colormap",
"[",
"abf",
".",
"currentSweep",
"]",
")",
"pylab",
".",
"ylabel",
"(",
"\"raw data (%s)\"",
"%",
"abf",
".",
"units",
")",
"pylab",
".",
"tight_layout",
"(",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
gain
|
easy way to plot a gain function.
|
doc/oldcode/swhlab/core/plot.py
|
def gain(abf):
"""easy way to plot a gain function."""
Ys=np.nan_to_num(swhlab.ap.getAvgBySweep(abf,'freq'))
Xs=abf.clampValues(abf.dataX[int(abf.protoSeqX[1]+.01)])
swhlab.plot.new(abf,title="gain function",xlabel="command current (pA)",
ylabel="average inst. freq. (Hz)")
pylab.plot(Xs,Ys,'.-',ms=20,alpha=.5,color='b')
pylab.axhline(0,alpha=.5,lw=2,color='r',ls="--")
pylab.margins(.1,.1)
|
def gain(abf):
"""easy way to plot a gain function."""
Ys=np.nan_to_num(swhlab.ap.getAvgBySweep(abf,'freq'))
Xs=abf.clampValues(abf.dataX[int(abf.protoSeqX[1]+.01)])
swhlab.plot.new(abf,title="gain function",xlabel="command current (pA)",
ylabel="average inst. freq. (Hz)")
pylab.plot(Xs,Ys,'.-',ms=20,alpha=.5,color='b')
pylab.axhline(0,alpha=.5,lw=2,color='r',ls="--")
pylab.margins(.1,.1)
|
[
"easy",
"way",
"to",
"plot",
"a",
"gain",
"function",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/plot.py#L86-L94
|
[
"def",
"gain",
"(",
"abf",
")",
":",
"Ys",
"=",
"np",
".",
"nan_to_num",
"(",
"swhlab",
".",
"ap",
".",
"getAvgBySweep",
"(",
"abf",
",",
"'freq'",
")",
")",
"Xs",
"=",
"abf",
".",
"clampValues",
"(",
"abf",
".",
"dataX",
"[",
"int",
"(",
"abf",
".",
"protoSeqX",
"[",
"1",
"]",
"+",
".01",
")",
"]",
")",
"swhlab",
".",
"plot",
".",
"new",
"(",
"abf",
",",
"title",
"=",
"\"gain function\"",
",",
"xlabel",
"=",
"\"command current (pA)\"",
",",
"ylabel",
"=",
"\"average inst. freq. (Hz)\"",
")",
"pylab",
".",
"plot",
"(",
"Xs",
",",
"Ys",
",",
"'.-'",
",",
"ms",
"=",
"20",
",",
"alpha",
"=",
".5",
",",
"color",
"=",
"'b'",
")",
"pylab",
".",
"axhline",
"(",
"0",
",",
"alpha",
"=",
".5",
",",
"lw",
"=",
"2",
",",
"color",
"=",
"'r'",
",",
"ls",
"=",
"\"--\"",
")",
"pylab",
".",
"margins",
"(",
".1",
",",
".1",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
IV
|
Given two time points (seconds) return IV data.
Optionally plots a fancy graph (with errorbars)
Returns [[AV],[SD]] for the given range.
|
doc/oldcode/swhlab/core/plot.py
|
def IV(abf,T1,T2,plotToo=True,color='b'):
"""
Given two time points (seconds) return IV data.
Optionally plots a fancy graph (with errorbars)
Returns [[AV],[SD]] for the given range.
"""
rangeData=abf.average_data([[T1,T2]]) #get the average data per sweep
AV,SD=rangeData[:,0,0],rangeData[:,0,1] #separate by average and SD
Xs=abf.clampValues(T1) #get clamp values at time point T1
if plotToo:
new(abf) #do this so it's the right shape and size
# plot the original sweep
pylab.subplot(221)
pylab.title("sweep data")
pylab.xlabel("time (s)")
pylab.ylabel("Measurement (%s)"%abf.units)
sweep(abf,'all',protocol=False)
pylab.axis([None,None,np.min(rangeData)-50,np.max(rangeData)+50])
pylab.axvspan(T1,T2,alpha=.1,color=color) #share measurement region
pylab.margins(0,.1)
# plot the data zoomed in
pylab.subplot(223)
pylab.title("measurement region")
pylab.xlabel("time (s)")
pylab.ylabel("Measurement (%s)"%abf.units)
sweep(abf,'all',protocol=False)
pylab.axis([T1-.05,T2+.05,np.min(rangeData)-50,np.max(rangeData)+50])
pylab.axvspan(T1,T2,alpha=.1,color=color) #share measurement region
pylab.margins(0,.1)
# plot the protocol
pylab.subplot(222)
pylab.title("protocol")
pylab.xlabel("time (s)")
pylab.ylabel("Command (%s)"%abf.unitsCommand)
sweep(abf,'all',protocol=True)
pylab.axvspan(T1,T2,alpha=.1,color=color) #share measurement region
pylab.margins(0,.1)
# plot the I/V
pylab.subplot(224)
pylab.grid(alpha=.5)
pylab.title("command / measure relationship")
pylab.xlabel("Command (%s)"%abf.unitsCommand)
pylab.ylabel("Measurement (%s)"%abf.units)
pylab.errorbar(Xs,AV,SD,capsize=0,marker='.',color=color)
if abf.units=="pA":
pylab.axhline(0,alpha=.5,lw=2,color='r',ls="--")
pylab.axvline(-70,alpha=.5,lw=2,color='r',ls="--")
else:
pylab.axhline(-70,alpha=.5,lw=2,color='r',ls="--")
pylab.axvline(0,alpha=.5,lw=2,color='r',ls="--")
pylab.margins(.1,.1)
annotate(abf)
return AV,SD
|
def IV(abf,T1,T2,plotToo=True,color='b'):
"""
Given two time points (seconds) return IV data.
Optionally plots a fancy graph (with errorbars)
Returns [[AV],[SD]] for the given range.
"""
rangeData=abf.average_data([[T1,T2]]) #get the average data per sweep
AV,SD=rangeData[:,0,0],rangeData[:,0,1] #separate by average and SD
Xs=abf.clampValues(T1) #get clamp values at time point T1
if plotToo:
new(abf) #do this so it's the right shape and size
# plot the original sweep
pylab.subplot(221)
pylab.title("sweep data")
pylab.xlabel("time (s)")
pylab.ylabel("Measurement (%s)"%abf.units)
sweep(abf,'all',protocol=False)
pylab.axis([None,None,np.min(rangeData)-50,np.max(rangeData)+50])
pylab.axvspan(T1,T2,alpha=.1,color=color) #share measurement region
pylab.margins(0,.1)
# plot the data zoomed in
pylab.subplot(223)
pylab.title("measurement region")
pylab.xlabel("time (s)")
pylab.ylabel("Measurement (%s)"%abf.units)
sweep(abf,'all',protocol=False)
pylab.axis([T1-.05,T2+.05,np.min(rangeData)-50,np.max(rangeData)+50])
pylab.axvspan(T1,T2,alpha=.1,color=color) #share measurement region
pylab.margins(0,.1)
# plot the protocol
pylab.subplot(222)
pylab.title("protocol")
pylab.xlabel("time (s)")
pylab.ylabel("Command (%s)"%abf.unitsCommand)
sweep(abf,'all',protocol=True)
pylab.axvspan(T1,T2,alpha=.1,color=color) #share measurement region
pylab.margins(0,.1)
# plot the I/V
pylab.subplot(224)
pylab.grid(alpha=.5)
pylab.title("command / measure relationship")
pylab.xlabel("Command (%s)"%abf.unitsCommand)
pylab.ylabel("Measurement (%s)"%abf.units)
pylab.errorbar(Xs,AV,SD,capsize=0,marker='.',color=color)
if abf.units=="pA":
pylab.axhline(0,alpha=.5,lw=2,color='r',ls="--")
pylab.axvline(-70,alpha=.5,lw=2,color='r',ls="--")
else:
pylab.axhline(-70,alpha=.5,lw=2,color='r',ls="--")
pylab.axvline(0,alpha=.5,lw=2,color='r',ls="--")
pylab.margins(.1,.1)
annotate(abf)
return AV,SD
|
[
"Given",
"two",
"time",
"points",
"(",
"seconds",
")",
"return",
"IV",
"data",
".",
"Optionally",
"plots",
"a",
"fancy",
"graph",
"(",
"with",
"errorbars",
")",
"Returns",
"[[",
"AV",
"]",
"[",
"SD",
"]]",
"for",
"the",
"given",
"range",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/plot.py#L96-L152
|
[
"def",
"IV",
"(",
"abf",
",",
"T1",
",",
"T2",
",",
"plotToo",
"=",
"True",
",",
"color",
"=",
"'b'",
")",
":",
"rangeData",
"=",
"abf",
".",
"average_data",
"(",
"[",
"[",
"T1",
",",
"T2",
"]",
"]",
")",
"#get the average data per sweep",
"AV",
",",
"SD",
"=",
"rangeData",
"[",
":",
",",
"0",
",",
"0",
"]",
",",
"rangeData",
"[",
":",
",",
"0",
",",
"1",
"]",
"#separate by average and SD",
"Xs",
"=",
"abf",
".",
"clampValues",
"(",
"T1",
")",
"#get clamp values at time point T1",
"if",
"plotToo",
":",
"new",
"(",
"abf",
")",
"#do this so it's the right shape and size",
"# plot the original sweep",
"pylab",
".",
"subplot",
"(",
"221",
")",
"pylab",
".",
"title",
"(",
"\"sweep data\"",
")",
"pylab",
".",
"xlabel",
"(",
"\"time (s)\"",
")",
"pylab",
".",
"ylabel",
"(",
"\"Measurement (%s)\"",
"%",
"abf",
".",
"units",
")",
"sweep",
"(",
"abf",
",",
"'all'",
",",
"protocol",
"=",
"False",
")",
"pylab",
".",
"axis",
"(",
"[",
"None",
",",
"None",
",",
"np",
".",
"min",
"(",
"rangeData",
")",
"-",
"50",
",",
"np",
".",
"max",
"(",
"rangeData",
")",
"+",
"50",
"]",
")",
"pylab",
".",
"axvspan",
"(",
"T1",
",",
"T2",
",",
"alpha",
"=",
".1",
",",
"color",
"=",
"color",
")",
"#share measurement region",
"pylab",
".",
"margins",
"(",
"0",
",",
".1",
")",
"# plot the data zoomed in",
"pylab",
".",
"subplot",
"(",
"223",
")",
"pylab",
".",
"title",
"(",
"\"measurement region\"",
")",
"pylab",
".",
"xlabel",
"(",
"\"time (s)\"",
")",
"pylab",
".",
"ylabel",
"(",
"\"Measurement (%s)\"",
"%",
"abf",
".",
"units",
")",
"sweep",
"(",
"abf",
",",
"'all'",
",",
"protocol",
"=",
"False",
")",
"pylab",
".",
"axis",
"(",
"[",
"T1",
"-",
".05",
",",
"T2",
"+",
".05",
",",
"np",
".",
"min",
"(",
"rangeData",
")",
"-",
"50",
",",
"np",
".",
"max",
"(",
"rangeData",
")",
"+",
"50",
"]",
")",
"pylab",
".",
"axvspan",
"(",
"T1",
",",
"T2",
",",
"alpha",
"=",
".1",
",",
"color",
"=",
"color",
")",
"#share measurement region",
"pylab",
".",
"margins",
"(",
"0",
",",
".1",
")",
"# plot the protocol",
"pylab",
".",
"subplot",
"(",
"222",
")",
"pylab",
".",
"title",
"(",
"\"protocol\"",
")",
"pylab",
".",
"xlabel",
"(",
"\"time (s)\"",
")",
"pylab",
".",
"ylabel",
"(",
"\"Command (%s)\"",
"%",
"abf",
".",
"unitsCommand",
")",
"sweep",
"(",
"abf",
",",
"'all'",
",",
"protocol",
"=",
"True",
")",
"pylab",
".",
"axvspan",
"(",
"T1",
",",
"T2",
",",
"alpha",
"=",
".1",
",",
"color",
"=",
"color",
")",
"#share measurement region",
"pylab",
".",
"margins",
"(",
"0",
",",
".1",
")",
"# plot the I/V",
"pylab",
".",
"subplot",
"(",
"224",
")",
"pylab",
".",
"grid",
"(",
"alpha",
"=",
".5",
")",
"pylab",
".",
"title",
"(",
"\"command / measure relationship\"",
")",
"pylab",
".",
"xlabel",
"(",
"\"Command (%s)\"",
"%",
"abf",
".",
"unitsCommand",
")",
"pylab",
".",
"ylabel",
"(",
"\"Measurement (%s)\"",
"%",
"abf",
".",
"units",
")",
"pylab",
".",
"errorbar",
"(",
"Xs",
",",
"AV",
",",
"SD",
",",
"capsize",
"=",
"0",
",",
"marker",
"=",
"'.'",
",",
"color",
"=",
"color",
")",
"if",
"abf",
".",
"units",
"==",
"\"pA\"",
":",
"pylab",
".",
"axhline",
"(",
"0",
",",
"alpha",
"=",
".5",
",",
"lw",
"=",
"2",
",",
"color",
"=",
"'r'",
",",
"ls",
"=",
"\"--\"",
")",
"pylab",
".",
"axvline",
"(",
"-",
"70",
",",
"alpha",
"=",
".5",
",",
"lw",
"=",
"2",
",",
"color",
"=",
"'r'",
",",
"ls",
"=",
"\"--\"",
")",
"else",
":",
"pylab",
".",
"axhline",
"(",
"-",
"70",
",",
"alpha",
"=",
".5",
",",
"lw",
"=",
"2",
",",
"color",
"=",
"'r'",
",",
"ls",
"=",
"\"--\"",
")",
"pylab",
".",
"axvline",
"(",
"0",
",",
"alpha",
"=",
".5",
",",
"lw",
"=",
"2",
",",
"color",
"=",
"'r'",
",",
"ls",
"=",
"\"--\"",
")",
"pylab",
".",
"margins",
"(",
".1",
",",
".1",
")",
"annotate",
"(",
"abf",
")",
"return",
"AV",
",",
"SD"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
comments
|
draw vertical lines at comment points. Defaults to seconds.
|
doc/oldcode/swhlab/core/plot.py
|
def comments(abf,minutes=False):
"""draw vertical lines at comment points. Defaults to seconds."""
if not len(abf.commentTimes):
return
for i in range(len(abf.commentTimes)):
t,c = abf.commentTimes[i],abf.commentTags[i]
if minutes:
t=t/60
pylab.axvline(t,lw=1,color='r',ls="--",alpha=.5)
X1,X2,Y1,Y2=pylab.axis()
Y2=Y2-abs(Y2-Y1)*.02
pylab.text(t,Y2,c,size=8,color='r',rotation='vertical',
ha='right',va='top',weight='bold',alpha=.5)
if minutes:
pylab.xlabel("minutes")
else:
pylab.xlabel("seconds")
|
def comments(abf,minutes=False):
"""draw vertical lines at comment points. Defaults to seconds."""
if not len(abf.commentTimes):
return
for i in range(len(abf.commentTimes)):
t,c = abf.commentTimes[i],abf.commentTags[i]
if minutes:
t=t/60
pylab.axvline(t,lw=1,color='r',ls="--",alpha=.5)
X1,X2,Y1,Y2=pylab.axis()
Y2=Y2-abs(Y2-Y1)*.02
pylab.text(t,Y2,c,size=8,color='r',rotation='vertical',
ha='right',va='top',weight='bold',alpha=.5)
if minutes:
pylab.xlabel("minutes")
else:
pylab.xlabel("seconds")
|
[
"draw",
"vertical",
"lines",
"at",
"comment",
"points",
".",
"Defaults",
"to",
"seconds",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/plot.py#L154-L170
|
[
"def",
"comments",
"(",
"abf",
",",
"minutes",
"=",
"False",
")",
":",
"if",
"not",
"len",
"(",
"abf",
".",
"commentTimes",
")",
":",
"return",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"abf",
".",
"commentTimes",
")",
")",
":",
"t",
",",
"c",
"=",
"abf",
".",
"commentTimes",
"[",
"i",
"]",
",",
"abf",
".",
"commentTags",
"[",
"i",
"]",
"if",
"minutes",
":",
"t",
"=",
"t",
"/",
"60",
"pylab",
".",
"axvline",
"(",
"t",
",",
"lw",
"=",
"1",
",",
"color",
"=",
"'r'",
",",
"ls",
"=",
"\"--\"",
",",
"alpha",
"=",
".5",
")",
"X1",
",",
"X2",
",",
"Y1",
",",
"Y2",
"=",
"pylab",
".",
"axis",
"(",
")",
"Y2",
"=",
"Y2",
"-",
"abs",
"(",
"Y2",
"-",
"Y1",
")",
"*",
".02",
"pylab",
".",
"text",
"(",
"t",
",",
"Y2",
",",
"c",
",",
"size",
"=",
"8",
",",
"color",
"=",
"'r'",
",",
"rotation",
"=",
"'vertical'",
",",
"ha",
"=",
"'right'",
",",
"va",
"=",
"'top'",
",",
"weight",
"=",
"'bold'",
",",
"alpha",
"=",
".5",
")",
"if",
"minutes",
":",
"pylab",
".",
"xlabel",
"(",
"\"minutes\"",
")",
"else",
":",
"pylab",
".",
"xlabel",
"(",
"\"seconds\"",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
dual
|
Plot two channels of current sweep (top/bottom).
|
doc/oldcode/swhlab/core/plot.py
|
def dual(ABF):
"""Plot two channels of current sweep (top/bottom)."""
new(ABF)
pylab.subplot(211)
pylab.title("Input A (channel 0)")
ABF.channel=0
sweep(ABF)
pylab.subplot(212)
pylab.title("Input B (channel 1)")
ABF.channel=1
sweep(ABF)
|
def dual(ABF):
"""Plot two channels of current sweep (top/bottom)."""
new(ABF)
pylab.subplot(211)
pylab.title("Input A (channel 0)")
ABF.channel=0
sweep(ABF)
pylab.subplot(212)
pylab.title("Input B (channel 1)")
ABF.channel=1
sweep(ABF)
|
[
"Plot",
"two",
"channels",
"of",
"current",
"sweep",
"(",
"top",
"/",
"bottom",
")",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/plot.py#L196-L206
|
[
"def",
"dual",
"(",
"ABF",
")",
":",
"new",
"(",
"ABF",
")",
"pylab",
".",
"subplot",
"(",
"211",
")",
"pylab",
".",
"title",
"(",
"\"Input A (channel 0)\"",
")",
"ABF",
".",
"channel",
"=",
"0",
"sweep",
"(",
"ABF",
")",
"pylab",
".",
"subplot",
"(",
"212",
")",
"pylab",
".",
"title",
"(",
"\"Input B (channel 1)\"",
")",
"ABF",
".",
"channel",
"=",
"1",
"sweep",
"(",
"ABF",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
sweep
|
Load a particular sweep then plot it.
If sweep is None or False, just plot current dataX/dataY.
If rainbow, it'll make it color coded prettily.
|
doc/oldcode/swhlab/core/plot.py
|
def sweep(ABF,sweep=None,rainbow=True,alpha=None,protocol=False,color='b',
continuous=False,offsetX=0,offsetY=0,minutes=False,
decimate=None,newFigure=False):
"""
Load a particular sweep then plot it.
If sweep is None or False, just plot current dataX/dataY.
If rainbow, it'll make it color coded prettily.
"""
if len(pylab.get_fignums())==0 or newFigure:
new(ABF,True)
if offsetY>0:
pylab.grid(None)
# figure which sweeps to plot
if sweep is None:
sweeps=[ABF.currentSweep]
if not ABF.currentSweep:
sweeps=[0]
elif sweep=="all":
sweeps=range(0,ABF.sweeps)
elif type(sweep) in [int,float]:
sweeps=[int(sweep)]
elif type(sweep) is list:
sweeps=sweep
else:
print("DONT KNOW WHAT TO DO WITH THIS SWEEPS!!!\n",type(sweep),sweep)
#figure out offsets:
if continuous:
offsetX=ABF.sweepInterval
# determine the colors to use
colors=[color]*len(sweeps) #detault to blue
if rainbow and len(sweeps)>1:
for i in range(len(sweeps)):
colors[i]=ABF.colormap[i]
if alpha is None and len(sweeps)==1:
alpha=1
if rainbow and alpha is None:
alpha=.5
# correct for alpha
if alpha is None:
alpha=1
# conversion to minutes?
if minutes == False:
minutes=1
else:
minutes=60
pylab.xlabel("minutes")
ABF.decimateMethod=decimate
# do the plotting of each sweep
for i in range(len(sweeps)):
ABF.setSweep(sweeps[i])
if protocol:
pylab.plot((np.array(ABF.protoX)/ABF.rate+offsetX*i)/minutes,
ABF.protoY+offsetY*i,
alpha=alpha,color=colors[i])
else:
pylab.plot((ABF.dataX+offsetX*i)/minutes,
ABF.dataY+offsetY*i,alpha=alpha,color=colors[i])
ABF.decimateMethod=None
pylab.margins(0,.02)
|
def sweep(ABF,sweep=None,rainbow=True,alpha=None,protocol=False,color='b',
continuous=False,offsetX=0,offsetY=0,minutes=False,
decimate=None,newFigure=False):
"""
Load a particular sweep then plot it.
If sweep is None or False, just plot current dataX/dataY.
If rainbow, it'll make it color coded prettily.
"""
if len(pylab.get_fignums())==0 or newFigure:
new(ABF,True)
if offsetY>0:
pylab.grid(None)
# figure which sweeps to plot
if sweep is None:
sweeps=[ABF.currentSweep]
if not ABF.currentSweep:
sweeps=[0]
elif sweep=="all":
sweeps=range(0,ABF.sweeps)
elif type(sweep) in [int,float]:
sweeps=[int(sweep)]
elif type(sweep) is list:
sweeps=sweep
else:
print("DONT KNOW WHAT TO DO WITH THIS SWEEPS!!!\n",type(sweep),sweep)
#figure out offsets:
if continuous:
offsetX=ABF.sweepInterval
# determine the colors to use
colors=[color]*len(sweeps) #detault to blue
if rainbow and len(sweeps)>1:
for i in range(len(sweeps)):
colors[i]=ABF.colormap[i]
if alpha is None and len(sweeps)==1:
alpha=1
if rainbow and alpha is None:
alpha=.5
# correct for alpha
if alpha is None:
alpha=1
# conversion to minutes?
if minutes == False:
minutes=1
else:
minutes=60
pylab.xlabel("minutes")
ABF.decimateMethod=decimate
# do the plotting of each sweep
for i in range(len(sweeps)):
ABF.setSweep(sweeps[i])
if protocol:
pylab.plot((np.array(ABF.protoX)/ABF.rate+offsetX*i)/minutes,
ABF.protoY+offsetY*i,
alpha=alpha,color=colors[i])
else:
pylab.plot((ABF.dataX+offsetX*i)/minutes,
ABF.dataY+offsetY*i,alpha=alpha,color=colors[i])
ABF.decimateMethod=None
pylab.margins(0,.02)
|
[
"Load",
"a",
"particular",
"sweep",
"then",
"plot",
"it",
".",
"If",
"sweep",
"is",
"None",
"or",
"False",
"just",
"plot",
"current",
"dataX",
"/",
"dataY",
".",
"If",
"rainbow",
"it",
"ll",
"make",
"it",
"color",
"coded",
"prettily",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/plot.py#L209-L273
|
[
"def",
"sweep",
"(",
"ABF",
",",
"sweep",
"=",
"None",
",",
"rainbow",
"=",
"True",
",",
"alpha",
"=",
"None",
",",
"protocol",
"=",
"False",
",",
"color",
"=",
"'b'",
",",
"continuous",
"=",
"False",
",",
"offsetX",
"=",
"0",
",",
"offsetY",
"=",
"0",
",",
"minutes",
"=",
"False",
",",
"decimate",
"=",
"None",
",",
"newFigure",
"=",
"False",
")",
":",
"if",
"len",
"(",
"pylab",
".",
"get_fignums",
"(",
")",
")",
"==",
"0",
"or",
"newFigure",
":",
"new",
"(",
"ABF",
",",
"True",
")",
"if",
"offsetY",
">",
"0",
":",
"pylab",
".",
"grid",
"(",
"None",
")",
"# figure which sweeps to plot",
"if",
"sweep",
"is",
"None",
":",
"sweeps",
"=",
"[",
"ABF",
".",
"currentSweep",
"]",
"if",
"not",
"ABF",
".",
"currentSweep",
":",
"sweeps",
"=",
"[",
"0",
"]",
"elif",
"sweep",
"==",
"\"all\"",
":",
"sweeps",
"=",
"range",
"(",
"0",
",",
"ABF",
".",
"sweeps",
")",
"elif",
"type",
"(",
"sweep",
")",
"in",
"[",
"int",
",",
"float",
"]",
":",
"sweeps",
"=",
"[",
"int",
"(",
"sweep",
")",
"]",
"elif",
"type",
"(",
"sweep",
")",
"is",
"list",
":",
"sweeps",
"=",
"sweep",
"else",
":",
"print",
"(",
"\"DONT KNOW WHAT TO DO WITH THIS SWEEPS!!!\\n\"",
",",
"type",
"(",
"sweep",
")",
",",
"sweep",
")",
"#figure out offsets:",
"if",
"continuous",
":",
"offsetX",
"=",
"ABF",
".",
"sweepInterval",
"# determine the colors to use",
"colors",
"=",
"[",
"color",
"]",
"*",
"len",
"(",
"sweeps",
")",
"#detault to blue",
"if",
"rainbow",
"and",
"len",
"(",
"sweeps",
")",
">",
"1",
":",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"sweeps",
")",
")",
":",
"colors",
"[",
"i",
"]",
"=",
"ABF",
".",
"colormap",
"[",
"i",
"]",
"if",
"alpha",
"is",
"None",
"and",
"len",
"(",
"sweeps",
")",
"==",
"1",
":",
"alpha",
"=",
"1",
"if",
"rainbow",
"and",
"alpha",
"is",
"None",
":",
"alpha",
"=",
".5",
"# correct for alpha",
"if",
"alpha",
"is",
"None",
":",
"alpha",
"=",
"1",
"# conversion to minutes?",
"if",
"minutes",
"==",
"False",
":",
"minutes",
"=",
"1",
"else",
":",
"minutes",
"=",
"60",
"pylab",
".",
"xlabel",
"(",
"\"minutes\"",
")",
"ABF",
".",
"decimateMethod",
"=",
"decimate",
"# do the plotting of each sweep",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"sweeps",
")",
")",
":",
"ABF",
".",
"setSweep",
"(",
"sweeps",
"[",
"i",
"]",
")",
"if",
"protocol",
":",
"pylab",
".",
"plot",
"(",
"(",
"np",
".",
"array",
"(",
"ABF",
".",
"protoX",
")",
"/",
"ABF",
".",
"rate",
"+",
"offsetX",
"*",
"i",
")",
"/",
"minutes",
",",
"ABF",
".",
"protoY",
"+",
"offsetY",
"*",
"i",
",",
"alpha",
"=",
"alpha",
",",
"color",
"=",
"colors",
"[",
"i",
"]",
")",
"else",
":",
"pylab",
".",
"plot",
"(",
"(",
"ABF",
".",
"dataX",
"+",
"offsetX",
"*",
"i",
")",
"/",
"minutes",
",",
"ABF",
".",
"dataY",
"+",
"offsetY",
"*",
"i",
",",
"alpha",
"=",
"alpha",
",",
"color",
"=",
"colors",
"[",
"i",
"]",
")",
"ABF",
".",
"decimateMethod",
"=",
"None",
"pylab",
".",
"margins",
"(",
"0",
",",
".02",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
annotate
|
stamp the bottom with file info.
|
doc/oldcode/swhlab/core/plot.py
|
def annotate(abf):
"""stamp the bottom with file info."""
msg="SWHLab %s "%str(swhlab.VERSION)
msg+="ID:%s "%abf.ID
msg+="CH:%d "%abf.channel
msg+="PROTOCOL:%s "%abf.protoComment
msg+="COMMAND: %d%s "%(abf.holding,abf.units)
msg+="GENERATED:%s "%'{0:%Y-%m-%d %H:%M:%S}'.format(datetime.datetime.now())
pylab.annotate(msg,(.001,.001),xycoords='figure fraction',ha='left',
va='bottom',color='#999999',family='monospace',size=8,
weight='bold')
if abf.nADC>1:
msg="Ch %d/%d"%(abf.channel+1,abf.nADC)
pylab.annotate(msg,(.01,.99),xycoords='figure fraction',ha='left',
va='top',color='#FF0000',family='monospace',size=12,
weight='bold')
|
def annotate(abf):
"""stamp the bottom with file info."""
msg="SWHLab %s "%str(swhlab.VERSION)
msg+="ID:%s "%abf.ID
msg+="CH:%d "%abf.channel
msg+="PROTOCOL:%s "%abf.protoComment
msg+="COMMAND: %d%s "%(abf.holding,abf.units)
msg+="GENERATED:%s "%'{0:%Y-%m-%d %H:%M:%S}'.format(datetime.datetime.now())
pylab.annotate(msg,(.001,.001),xycoords='figure fraction',ha='left',
va='bottom',color='#999999',family='monospace',size=8,
weight='bold')
if abf.nADC>1:
msg="Ch %d/%d"%(abf.channel+1,abf.nADC)
pylab.annotate(msg,(.01,.99),xycoords='figure fraction',ha='left',
va='top',color='#FF0000',family='monospace',size=12,
weight='bold')
|
[
"stamp",
"the",
"bottom",
"with",
"file",
"info",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/plot.py#L275-L290
|
[
"def",
"annotate",
"(",
"abf",
")",
":",
"msg",
"=",
"\"SWHLab %s \"",
"%",
"str",
"(",
"swhlab",
".",
"VERSION",
")",
"msg",
"+=",
"\"ID:%s \"",
"%",
"abf",
".",
"ID",
"msg",
"+=",
"\"CH:%d \"",
"%",
"abf",
".",
"channel",
"msg",
"+=",
"\"PROTOCOL:%s \"",
"%",
"abf",
".",
"protoComment",
"msg",
"+=",
"\"COMMAND: %d%s \"",
"%",
"(",
"abf",
".",
"holding",
",",
"abf",
".",
"units",
")",
"msg",
"+=",
"\"GENERATED:%s \"",
"%",
"'{0:%Y-%m-%d %H:%M:%S}'",
".",
"format",
"(",
"datetime",
".",
"datetime",
".",
"now",
"(",
")",
")",
"pylab",
".",
"annotate",
"(",
"msg",
",",
"(",
".001",
",",
".001",
")",
",",
"xycoords",
"=",
"'figure fraction'",
",",
"ha",
"=",
"'left'",
",",
"va",
"=",
"'bottom'",
",",
"color",
"=",
"'#999999'",
",",
"family",
"=",
"'monospace'",
",",
"size",
"=",
"8",
",",
"weight",
"=",
"'bold'",
")",
"if",
"abf",
".",
"nADC",
">",
"1",
":",
"msg",
"=",
"\"Ch %d/%d\"",
"%",
"(",
"abf",
".",
"channel",
"+",
"1",
",",
"abf",
".",
"nADC",
")",
"pylab",
".",
"annotate",
"(",
"msg",
",",
"(",
".01",
",",
".99",
")",
",",
"xycoords",
"=",
"'figure fraction'",
",",
"ha",
"=",
"'left'",
",",
"va",
"=",
"'top'",
",",
"color",
"=",
"'#FF0000'",
",",
"family",
"=",
"'monospace'",
",",
"size",
"=",
"12",
",",
"weight",
"=",
"'bold'",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
new
|
makes a new matplotlib figure with default dims and DPI.
Also labels it with pA or mV depending on ABF.
|
doc/oldcode/swhlab/core/plot.py
|
def new(ABF,forceNewFigure=False,title=None,xlabel=None,ylabel=None):
"""
makes a new matplotlib figure with default dims and DPI.
Also labels it with pA or mV depending on ABF.
"""
if len(pylab.get_fignums()) and forceNewFigure==False:
#print("adding to existing figure")
return
pylab.figure(figsize=(8,6))
pylab.grid(alpha=.5)
pylab.title(ABF.ID)
pylab.ylabel(ABF.units)
pylab.xlabel("seconds")
if xlabel:
pylab.xlabel(xlabel)
if ylabel:
pylab.ylabel(ylabel)
if title:
pylab.title(title)
annotate(ABF)
|
def new(ABF,forceNewFigure=False,title=None,xlabel=None,ylabel=None):
"""
makes a new matplotlib figure with default dims and DPI.
Also labels it with pA or mV depending on ABF.
"""
if len(pylab.get_fignums()) and forceNewFigure==False:
#print("adding to existing figure")
return
pylab.figure(figsize=(8,6))
pylab.grid(alpha=.5)
pylab.title(ABF.ID)
pylab.ylabel(ABF.units)
pylab.xlabel("seconds")
if xlabel:
pylab.xlabel(xlabel)
if ylabel:
pylab.ylabel(ylabel)
if title:
pylab.title(title)
annotate(ABF)
|
[
"makes",
"a",
"new",
"matplotlib",
"figure",
"with",
"default",
"dims",
"and",
"DPI",
".",
"Also",
"labels",
"it",
"with",
"pA",
"or",
"mV",
"depending",
"on",
"ABF",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/plot.py#L292-L311
|
[
"def",
"new",
"(",
"ABF",
",",
"forceNewFigure",
"=",
"False",
",",
"title",
"=",
"None",
",",
"xlabel",
"=",
"None",
",",
"ylabel",
"=",
"None",
")",
":",
"if",
"len",
"(",
"pylab",
".",
"get_fignums",
"(",
")",
")",
"and",
"forceNewFigure",
"==",
"False",
":",
"#print(\"adding to existing figure\")",
"return",
"pylab",
".",
"figure",
"(",
"figsize",
"=",
"(",
"8",
",",
"6",
")",
")",
"pylab",
".",
"grid",
"(",
"alpha",
"=",
".5",
")",
"pylab",
".",
"title",
"(",
"ABF",
".",
"ID",
")",
"pylab",
".",
"ylabel",
"(",
"ABF",
".",
"units",
")",
"pylab",
".",
"xlabel",
"(",
"\"seconds\"",
")",
"if",
"xlabel",
":",
"pylab",
".",
"xlabel",
"(",
"xlabel",
")",
"if",
"ylabel",
":",
"pylab",
".",
"ylabel",
"(",
"ylabel",
")",
"if",
"title",
":",
"pylab",
".",
"title",
"(",
"title",
")",
"annotate",
"(",
"ABF",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
save
|
Save the pylab figure somewhere.
If fname==False, show it instead.
Height force > dpi force
if a tag is given instead of a filename, save it alongside the ABF
|
doc/oldcode/swhlab/core/plot.py
|
def save(abf,fname=None,tag=None,width=700,close=True,facecolor='w',
resize=True):
"""
Save the pylab figure somewhere.
If fname==False, show it instead.
Height force > dpi force
if a tag is given instead of a filename, save it alongside the ABF
"""
if len(pylab.gca().get_lines())==0:
print("can't save, no figure!")
return
if resize:
pylab.tight_layout()
pylab.subplots_adjust(bottom=.1)
annotate(abf)
if tag:
fname = abf.outpath+abf.ID+"_"+tag+".png"
inchesX,inchesY = pylab.gcf().get_size_inches()
dpi=width/inchesX
if fname:
if not os.path.exists(abf.outpath):
os.mkdir(abf.outpath)
print(" <- saving [%s] at %d DPI (%dx%d)"%(os.path.basename(fname),dpi,inchesX*dpi,inchesY*dpi))
pylab.savefig(fname,dpi=dpi,facecolor=facecolor)
else:
pylab.show()
if close:
pylab.close()
|
def save(abf,fname=None,tag=None,width=700,close=True,facecolor='w',
resize=True):
"""
Save the pylab figure somewhere.
If fname==False, show it instead.
Height force > dpi force
if a tag is given instead of a filename, save it alongside the ABF
"""
if len(pylab.gca().get_lines())==0:
print("can't save, no figure!")
return
if resize:
pylab.tight_layout()
pylab.subplots_adjust(bottom=.1)
annotate(abf)
if tag:
fname = abf.outpath+abf.ID+"_"+tag+".png"
inchesX,inchesY = pylab.gcf().get_size_inches()
dpi=width/inchesX
if fname:
if not os.path.exists(abf.outpath):
os.mkdir(abf.outpath)
print(" <- saving [%s] at %d DPI (%dx%d)"%(os.path.basename(fname),dpi,inchesX*dpi,inchesY*dpi))
pylab.savefig(fname,dpi=dpi,facecolor=facecolor)
else:
pylab.show()
if close:
pylab.close()
|
[
"Save",
"the",
"pylab",
"figure",
"somewhere",
".",
"If",
"fname",
"==",
"False",
"show",
"it",
"instead",
".",
"Height",
"force",
">",
"dpi",
"force",
"if",
"a",
"tag",
"is",
"given",
"instead",
"of",
"a",
"filename",
"save",
"it",
"alongside",
"the",
"ABF"
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/swhlab/core/plot.py#L317-L344
|
[
"def",
"save",
"(",
"abf",
",",
"fname",
"=",
"None",
",",
"tag",
"=",
"None",
",",
"width",
"=",
"700",
",",
"close",
"=",
"True",
",",
"facecolor",
"=",
"'w'",
",",
"resize",
"=",
"True",
")",
":",
"if",
"len",
"(",
"pylab",
".",
"gca",
"(",
")",
".",
"get_lines",
"(",
")",
")",
"==",
"0",
":",
"print",
"(",
"\"can't save, no figure!\"",
")",
"return",
"if",
"resize",
":",
"pylab",
".",
"tight_layout",
"(",
")",
"pylab",
".",
"subplots_adjust",
"(",
"bottom",
"=",
".1",
")",
"annotate",
"(",
"abf",
")",
"if",
"tag",
":",
"fname",
"=",
"abf",
".",
"outpath",
"+",
"abf",
".",
"ID",
"+",
"\"_\"",
"+",
"tag",
"+",
"\".png\"",
"inchesX",
",",
"inchesY",
"=",
"pylab",
".",
"gcf",
"(",
")",
".",
"get_size_inches",
"(",
")",
"dpi",
"=",
"width",
"/",
"inchesX",
"if",
"fname",
":",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"abf",
".",
"outpath",
")",
":",
"os",
".",
"mkdir",
"(",
"abf",
".",
"outpath",
")",
"print",
"(",
"\" <- saving [%s] at %d DPI (%dx%d)\"",
"%",
"(",
"os",
".",
"path",
".",
"basename",
"(",
"fname",
")",
",",
"dpi",
",",
"inchesX",
"*",
"dpi",
",",
"inchesY",
"*",
"dpi",
")",
")",
"pylab",
".",
"savefig",
"(",
"fname",
",",
"dpi",
"=",
"dpi",
",",
"facecolor",
"=",
"facecolor",
")",
"else",
":",
"pylab",
".",
"show",
"(",
")",
"if",
"close",
":",
"pylab",
".",
"close",
"(",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
tryLoadingFrom
|
if the module is in this path, load it from the local folder.
|
swhlab/__init__.py
|
def tryLoadingFrom(tryPath,moduleName='swhlab'):
"""if the module is in this path, load it from the local folder."""
if not 'site-packages' in swhlab.__file__:
print("loaded custom swhlab module from",
os.path.dirname(swhlab.__file__))
return # no need to warn if it's already outside.
while len(tryPath)>5:
sp=tryPath+"/swhlab/" # imaginary swhlab module path
if os.path.isdir(sp) and os.path.exists(sp+"/__init__.py"):
if not os.path.dirname(tryPath) in sys.path:
sys.path.insert(0,os.path.dirname(tryPath))
print("#"*80)
print("# WARNING: using site-packages swhlab module")
print("#"*80)
tryPath=os.path.dirname(tryPath)
return
|
def tryLoadingFrom(tryPath,moduleName='swhlab'):
"""if the module is in this path, load it from the local folder."""
if not 'site-packages' in swhlab.__file__:
print("loaded custom swhlab module from",
os.path.dirname(swhlab.__file__))
return # no need to warn if it's already outside.
while len(tryPath)>5:
sp=tryPath+"/swhlab/" # imaginary swhlab module path
if os.path.isdir(sp) and os.path.exists(sp+"/__init__.py"):
if not os.path.dirname(tryPath) in sys.path:
sys.path.insert(0,os.path.dirname(tryPath))
print("#"*80)
print("# WARNING: using site-packages swhlab module")
print("#"*80)
tryPath=os.path.dirname(tryPath)
return
|
[
"if",
"the",
"module",
"is",
"in",
"this",
"path",
"load",
"it",
"from",
"the",
"local",
"folder",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/__init__.py#L19-L34
|
[
"def",
"tryLoadingFrom",
"(",
"tryPath",
",",
"moduleName",
"=",
"'swhlab'",
")",
":",
"if",
"not",
"'site-packages'",
"in",
"swhlab",
".",
"__file__",
":",
"print",
"(",
"\"loaded custom swhlab module from\"",
",",
"os",
".",
"path",
".",
"dirname",
"(",
"swhlab",
".",
"__file__",
")",
")",
"return",
"# no need to warn if it's already outside.",
"while",
"len",
"(",
"tryPath",
")",
">",
"5",
":",
"sp",
"=",
"tryPath",
"+",
"\"/swhlab/\"",
"# imaginary swhlab module path",
"if",
"os",
".",
"path",
".",
"isdir",
"(",
"sp",
")",
"and",
"os",
".",
"path",
".",
"exists",
"(",
"sp",
"+",
"\"/__init__.py\"",
")",
":",
"if",
"not",
"os",
".",
"path",
".",
"dirname",
"(",
"tryPath",
")",
"in",
"sys",
".",
"path",
":",
"sys",
".",
"path",
".",
"insert",
"(",
"0",
",",
"os",
".",
"path",
".",
"dirname",
"(",
"tryPath",
")",
")",
"print",
"(",
"\"#\"",
"*",
"80",
")",
"print",
"(",
"\"# WARNING: using site-packages swhlab module\"",
")",
"print",
"(",
"\"#\"",
"*",
"80",
")",
"tryPath",
"=",
"os",
".",
"path",
".",
"dirname",
"(",
"tryPath",
")",
"return"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
DynamicArgs.update
|
Called to update the state of the iterator. This methods
receives the set of task ids from the previous set of tasks
together with the launch information to allow the output
values to be parsed using the output_extractor. This data is then
used to determine the next desired point in the parameter
space by calling the _update_state method.
|
lancet/dynamic.py
|
def update(self, tids, info):
"""
Called to update the state of the iterator. This methods
receives the set of task ids from the previous set of tasks
together with the launch information to allow the output
values to be parsed using the output_extractor. This data is then
used to determine the next desired point in the parameter
space by calling the _update_state method.
"""
outputs_dir = os.path.join(info['root_directory'], 'streams')
pattern = '%s_*_tid_*{tid}.o.{tid}*' % info['batch_name']
flist = os.listdir(outputs_dir)
try:
outputs = []
for tid in tids:
matches = fnmatch.filter(flist, pattern.format(tid=tid))
if len(matches) != 1:
self.warning("No unique output file for tid %d" % tid)
contents = open(os.path.join(outputs_dir, matches[0]),'r').read()
outputs.append(self.output_extractor(contents))
self._next_val = self._update_state(outputs)
self.trace.append((outputs, self._next_val))
except:
self.warning("Cannot load required output files. Cannot continue.")
self._next_val = StopIteration
|
def update(self, tids, info):
"""
Called to update the state of the iterator. This methods
receives the set of task ids from the previous set of tasks
together with the launch information to allow the output
values to be parsed using the output_extractor. This data is then
used to determine the next desired point in the parameter
space by calling the _update_state method.
"""
outputs_dir = os.path.join(info['root_directory'], 'streams')
pattern = '%s_*_tid_*{tid}.o.{tid}*' % info['batch_name']
flist = os.listdir(outputs_dir)
try:
outputs = []
for tid in tids:
matches = fnmatch.filter(flist, pattern.format(tid=tid))
if len(matches) != 1:
self.warning("No unique output file for tid %d" % tid)
contents = open(os.path.join(outputs_dir, matches[0]),'r').read()
outputs.append(self.output_extractor(contents))
self._next_val = self._update_state(outputs)
self.trace.append((outputs, self._next_val))
except:
self.warning("Cannot load required output files. Cannot continue.")
self._next_val = StopIteration
|
[
"Called",
"to",
"update",
"the",
"state",
"of",
"the",
"iterator",
".",
"This",
"methods",
"receives",
"the",
"set",
"of",
"task",
"ids",
"from",
"the",
"previous",
"set",
"of",
"tasks",
"together",
"with",
"the",
"launch",
"information",
"to",
"allow",
"the",
"output",
"values",
"to",
"be",
"parsed",
"using",
"the",
"output_extractor",
".",
"This",
"data",
"is",
"then",
"used",
"to",
"determine",
"the",
"next",
"desired",
"point",
"in",
"the",
"parameter",
"space",
"by",
"calling",
"the",
"_update_state",
"method",
"."
] |
ioam/lancet
|
python
|
https://github.com/ioam/lancet/blob/1fbbf88fa0e8974ff9ed462e3cb11722ddebdd6e/lancet/dynamic.py#L80-L105
|
[
"def",
"update",
"(",
"self",
",",
"tids",
",",
"info",
")",
":",
"outputs_dir",
"=",
"os",
".",
"path",
".",
"join",
"(",
"info",
"[",
"'root_directory'",
"]",
",",
"'streams'",
")",
"pattern",
"=",
"'%s_*_tid_*{tid}.o.{tid}*'",
"%",
"info",
"[",
"'batch_name'",
"]",
"flist",
"=",
"os",
".",
"listdir",
"(",
"outputs_dir",
")",
"try",
":",
"outputs",
"=",
"[",
"]",
"for",
"tid",
"in",
"tids",
":",
"matches",
"=",
"fnmatch",
".",
"filter",
"(",
"flist",
",",
"pattern",
".",
"format",
"(",
"tid",
"=",
"tid",
")",
")",
"if",
"len",
"(",
"matches",
")",
"!=",
"1",
":",
"self",
".",
"warning",
"(",
"\"No unique output file for tid %d\"",
"%",
"tid",
")",
"contents",
"=",
"open",
"(",
"os",
".",
"path",
".",
"join",
"(",
"outputs_dir",
",",
"matches",
"[",
"0",
"]",
")",
",",
"'r'",
")",
".",
"read",
"(",
")",
"outputs",
".",
"append",
"(",
"self",
".",
"output_extractor",
"(",
"contents",
")",
")",
"self",
".",
"_next_val",
"=",
"self",
".",
"_update_state",
"(",
"outputs",
")",
"self",
".",
"trace",
".",
"append",
"(",
"(",
"outputs",
",",
"self",
".",
"_next_val",
")",
")",
"except",
":",
"self",
".",
"warning",
"(",
"\"Cannot load required output files. Cannot continue.\"",
")",
"self",
".",
"_next_val",
"=",
"StopIteration"
] |
1fbbf88fa0e8974ff9ed462e3cb11722ddebdd6e
|
valid
|
DynamicArgs.show
|
When dynamic, not all argument values may be available.
|
lancet/dynamic.py
|
def show(self):
"""
When dynamic, not all argument values may be available.
"""
copied = self.copy()
enumerated = [el for el in enumerate(copied)]
for (group_ind, specs) in enumerated:
if len(enumerated) > 1: print("Group %d" % group_ind)
ordering = self.constant_keys + self.varying_keys
# Ordered nicely by varying_keys definition.
spec_lines = [', '.join(['%s=%s' % (k, s[k]) for k in ordering]) for s in specs]
print('\n'.join(['%d: %s' % (i,l) for (i,l) in enumerate(spec_lines)]))
print('Remaining arguments not available for %s' % self.__class__.__name__)
|
def show(self):
"""
When dynamic, not all argument values may be available.
"""
copied = self.copy()
enumerated = [el for el in enumerate(copied)]
for (group_ind, specs) in enumerated:
if len(enumerated) > 1: print("Group %d" % group_ind)
ordering = self.constant_keys + self.varying_keys
# Ordered nicely by varying_keys definition.
spec_lines = [', '.join(['%s=%s' % (k, s[k]) for k in ordering]) for s in specs]
print('\n'.join(['%d: %s' % (i,l) for (i,l) in enumerate(spec_lines)]))
print('Remaining arguments not available for %s' % self.__class__.__name__)
|
[
"When",
"dynamic",
"not",
"all",
"argument",
"values",
"may",
"be",
"available",
"."
] |
ioam/lancet
|
python
|
https://github.com/ioam/lancet/blob/1fbbf88fa0e8974ff9ed462e3cb11722ddebdd6e/lancet/dynamic.py#L108-L121
|
[
"def",
"show",
"(",
"self",
")",
":",
"copied",
"=",
"self",
".",
"copy",
"(",
")",
"enumerated",
"=",
"[",
"el",
"for",
"el",
"in",
"enumerate",
"(",
"copied",
")",
"]",
"for",
"(",
"group_ind",
",",
"specs",
")",
"in",
"enumerated",
":",
"if",
"len",
"(",
"enumerated",
")",
">",
"1",
":",
"print",
"(",
"\"Group %d\"",
"%",
"group_ind",
")",
"ordering",
"=",
"self",
".",
"constant_keys",
"+",
"self",
".",
"varying_keys",
"# Ordered nicely by varying_keys definition.",
"spec_lines",
"=",
"[",
"', '",
".",
"join",
"(",
"[",
"'%s=%s'",
"%",
"(",
"k",
",",
"s",
"[",
"k",
"]",
")",
"for",
"k",
"in",
"ordering",
"]",
")",
"for",
"s",
"in",
"specs",
"]",
"print",
"(",
"'\\n'",
".",
"join",
"(",
"[",
"'%d: %s'",
"%",
"(",
"i",
",",
"l",
")",
"for",
"(",
"i",
",",
"l",
")",
"in",
"enumerate",
"(",
"spec_lines",
")",
"]",
")",
")",
"print",
"(",
"'Remaining arguments not available for %s'",
"%",
"self",
".",
"__class__",
".",
"__name__",
")"
] |
1fbbf88fa0e8974ff9ed462e3cb11722ddebdd6e
|
valid
|
DynamicArgs._trace_summary
|
Summarizes the trace of values used to update the DynamicArgs
and the arguments subsequently returned. May be used to
implement the summary method.
|
lancet/dynamic.py
|
def _trace_summary(self):
"""
Summarizes the trace of values used to update the DynamicArgs
and the arguments subsequently returned. May be used to
implement the summary method.
"""
for (i, (val, args)) in enumerate(self.trace):
if args is StopIteration:
info = "Terminated"
else:
pprint = ','.join('{' + ','.join('%s=%r' % (k,v)
for (k,v) in arg.items()) + '}' for arg in args)
info = ("exploring arguments [%s]" % pprint )
if i == 0: print("Step %d: Initially %s." % (i, info))
else: print("Step %d: %s after receiving input(s) %s." % (i, info.capitalize(), val))
|
def _trace_summary(self):
"""
Summarizes the trace of values used to update the DynamicArgs
and the arguments subsequently returned. May be used to
implement the summary method.
"""
for (i, (val, args)) in enumerate(self.trace):
if args is StopIteration:
info = "Terminated"
else:
pprint = ','.join('{' + ','.join('%s=%r' % (k,v)
for (k,v) in arg.items()) + '}' for arg in args)
info = ("exploring arguments [%s]" % pprint )
if i == 0: print("Step %d: Initially %s." % (i, info))
else: print("Step %d: %s after receiving input(s) %s." % (i, info.capitalize(), val))
|
[
"Summarizes",
"the",
"trace",
"of",
"values",
"used",
"to",
"update",
"the",
"DynamicArgs",
"and",
"the",
"arguments",
"subsequently",
"returned",
".",
"May",
"be",
"used",
"to",
"implement",
"the",
"summary",
"method",
"."
] |
ioam/lancet
|
python
|
https://github.com/ioam/lancet/blob/1fbbf88fa0e8974ff9ed462e3cb11722ddebdd6e/lancet/dynamic.py#L124-L139
|
[
"def",
"_trace_summary",
"(",
"self",
")",
":",
"for",
"(",
"i",
",",
"(",
"val",
",",
"args",
")",
")",
"in",
"enumerate",
"(",
"self",
".",
"trace",
")",
":",
"if",
"args",
"is",
"StopIteration",
":",
"info",
"=",
"\"Terminated\"",
"else",
":",
"pprint",
"=",
"','",
".",
"join",
"(",
"'{'",
"+",
"','",
".",
"join",
"(",
"'%s=%r'",
"%",
"(",
"k",
",",
"v",
")",
"for",
"(",
"k",
",",
"v",
")",
"in",
"arg",
".",
"items",
"(",
")",
")",
"+",
"'}'",
"for",
"arg",
"in",
"args",
")",
"info",
"=",
"(",
"\"exploring arguments [%s]\"",
"%",
"pprint",
")",
"if",
"i",
"==",
"0",
":",
"print",
"(",
"\"Step %d: Initially %s.\"",
"%",
"(",
"i",
",",
"info",
")",
")",
"else",
":",
"print",
"(",
"\"Step %d: %s after receiving input(s) %s.\"",
"%",
"(",
"i",
",",
"info",
".",
"capitalize",
"(",
")",
",",
"val",
")",
")"
] |
1fbbf88fa0e8974ff9ed462e3cb11722ddebdd6e
|
valid
|
SimpleGradientDescent._update_state
|
Takes as input a list or tuple of two elements. First the
value returned by incrementing by 'stepsize' followed by the
value returned after a 'stepsize' decrement.
|
lancet/dynamic.py
|
def _update_state(self, vals):
"""
Takes as input a list or tuple of two elements. First the
value returned by incrementing by 'stepsize' followed by the
value returned after a 'stepsize' decrement.
"""
self._steps_complete += 1
if self._steps_complete == self.max_steps:
self._termination_info = (False, self._best_val, self._arg)
return StopIteration
arg_inc, arg_dec = vals
best_val = min(arg_inc, arg_dec, self._best_val)
if best_val == self._best_val:
self._termination_info = (True, best_val, self._arg)
return StopIteration
self._arg += self.stepsize if (arg_dec > arg_inc) else -self.stepsize
self._best_val= best_val
return [{self.key:self._arg+self.stepsize},
{self.key:self._arg-self.stepsize}]
|
def _update_state(self, vals):
"""
Takes as input a list or tuple of two elements. First the
value returned by incrementing by 'stepsize' followed by the
value returned after a 'stepsize' decrement.
"""
self._steps_complete += 1
if self._steps_complete == self.max_steps:
self._termination_info = (False, self._best_val, self._arg)
return StopIteration
arg_inc, arg_dec = vals
best_val = min(arg_inc, arg_dec, self._best_val)
if best_val == self._best_val:
self._termination_info = (True, best_val, self._arg)
return StopIteration
self._arg += self.stepsize if (arg_dec > arg_inc) else -self.stepsize
self._best_val= best_val
return [{self.key:self._arg+self.stepsize},
{self.key:self._arg-self.stepsize}]
|
[
"Takes",
"as",
"input",
"a",
"list",
"or",
"tuple",
"of",
"two",
"elements",
".",
"First",
"the",
"value",
"returned",
"by",
"incrementing",
"by",
"stepsize",
"followed",
"by",
"the",
"value",
"returned",
"after",
"a",
"stepsize",
"decrement",
"."
] |
ioam/lancet
|
python
|
https://github.com/ioam/lancet/blob/1fbbf88fa0e8974ff9ed462e3cb11722ddebdd6e/lancet/dynamic.py#L228-L248
|
[
"def",
"_update_state",
"(",
"self",
",",
"vals",
")",
":",
"self",
".",
"_steps_complete",
"+=",
"1",
"if",
"self",
".",
"_steps_complete",
"==",
"self",
".",
"max_steps",
":",
"self",
".",
"_termination_info",
"=",
"(",
"False",
",",
"self",
".",
"_best_val",
",",
"self",
".",
"_arg",
")",
"return",
"StopIteration",
"arg_inc",
",",
"arg_dec",
"=",
"vals",
"best_val",
"=",
"min",
"(",
"arg_inc",
",",
"arg_dec",
",",
"self",
".",
"_best_val",
")",
"if",
"best_val",
"==",
"self",
".",
"_best_val",
":",
"self",
".",
"_termination_info",
"=",
"(",
"True",
",",
"best_val",
",",
"self",
".",
"_arg",
")",
"return",
"StopIteration",
"self",
".",
"_arg",
"+=",
"self",
".",
"stepsize",
"if",
"(",
"arg_dec",
">",
"arg_inc",
")",
"else",
"-",
"self",
".",
"stepsize",
"self",
".",
"_best_val",
"=",
"best_val",
"return",
"[",
"{",
"self",
".",
"key",
":",
"self",
".",
"_arg",
"+",
"self",
".",
"stepsize",
"}",
",",
"{",
"self",
".",
"key",
":",
"self",
".",
"_arg",
"-",
"self",
".",
"stepsize",
"}",
"]"
] |
1fbbf88fa0e8974ff9ed462e3cb11722ddebdd6e
|
valid
|
proto_unknown
|
protocol: unknown.
|
swhlab/analysis/protocols.py
|
def proto_unknown(theABF):
"""protocol: unknown."""
abf=ABF(theABF)
abf.log.info("analyzing as an unknown protocol")
plot=ABFplot(abf)
plot.rainbow=False
plot.title=None
plot.figure_height,plot.figure_width=SQUARESIZE,SQUARESIZE
plot.kwargs["lw"]=.5
plot.figure_chronological()
plt.gca().set_axis_bgcolor('#AAAAAA') # different background if unknown protocol
frameAndSave(abf,"UNKNOWN")
|
def proto_unknown(theABF):
"""protocol: unknown."""
abf=ABF(theABF)
abf.log.info("analyzing as an unknown protocol")
plot=ABFplot(abf)
plot.rainbow=False
plot.title=None
plot.figure_height,plot.figure_width=SQUARESIZE,SQUARESIZE
plot.kwargs["lw"]=.5
plot.figure_chronological()
plt.gca().set_axis_bgcolor('#AAAAAA') # different background if unknown protocol
frameAndSave(abf,"UNKNOWN")
|
[
"protocol",
":",
"unknown",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/analysis/protocols.py#L43-L54
|
[
"def",
"proto_unknown",
"(",
"theABF",
")",
":",
"abf",
"=",
"ABF",
"(",
"theABF",
")",
"abf",
".",
"log",
".",
"info",
"(",
"\"analyzing as an unknown protocol\"",
")",
"plot",
"=",
"ABFplot",
"(",
"abf",
")",
"plot",
".",
"rainbow",
"=",
"False",
"plot",
".",
"title",
"=",
"None",
"plot",
".",
"figure_height",
",",
"plot",
".",
"figure_width",
"=",
"SQUARESIZE",
",",
"SQUARESIZE",
"plot",
".",
"kwargs",
"[",
"\"lw\"",
"]",
"=",
".5",
"plot",
".",
"figure_chronological",
"(",
")",
"plt",
".",
"gca",
"(",
")",
".",
"set_axis_bgcolor",
"(",
"'#AAAAAA'",
")",
"# different background if unknown protocol",
"frameAndSave",
"(",
"abf",
",",
"\"UNKNOWN\"",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
proto_0111
|
protocol: IC ramp for AP shape analysis.
|
swhlab/analysis/protocols.py
|
def proto_0111(theABF):
"""protocol: IC ramp for AP shape analysis."""
abf=ABF(theABF)
abf.log.info("analyzing as an IC ramp")
# AP detection
ap=AP(abf)
ap.detect()
# also calculate derivative for each sweep
abf.derivative=True
# create the multi-plot figure
plt.figure(figsize=(SQUARESIZE,SQUARESIZE))
ax1=plt.subplot(221)
plt.ylabel(abf.units2)
ax2=plt.subplot(222,sharey=ax1)
ax3=plt.subplot(223)
plt.ylabel(abf.unitsD2)
ax4=plt.subplot(224,sharey=ax3)
# put data in each subplot
for sweep in range(abf.sweeps):
abf.setsweep(sweep)
ax1.plot(abf.sweepX,abf.sweepY,color='b',lw=.25)
ax2.plot(abf.sweepX,abf.sweepY,color='b')
ax3.plot(abf.sweepX,abf.sweepD,color='r',lw=.25)
ax4.plot(abf.sweepX,abf.sweepD,color='r')
# modify axis
for ax in [ax1,ax2,ax3,ax4]: # everything
ax.margins(0,.1)
ax.grid(alpha=.5)
for ax in [ax3,ax4]: # only derivative APs
ax.axhline(-100,color='r',alpha=.5,ls="--",lw=2)
for ax in [ax2,ax4]: # only zoomed in APs
ax.get_yaxis().set_visible(False)
if len(ap.APs):
firstAP=ap.APs[0]["T"]
ax2.axis([firstAP-.25,firstAP+.25,None,None])
ax4.axis([firstAP-.01,firstAP+.01,None,None])
# show message from first AP
if len(ap.APs):
firstAP=ap.APs[0]
msg="\n".join(["%s = %s"%(x,str(firstAP[x])) for x in sorted(firstAP.keys()) if not "I" in x[-2:]])
plt.subplot(221)
plt.gca().text(0.02, 0.98, msg, transform= plt.gca().transAxes, fontsize=10, verticalalignment='top', family='monospace')
# save it
plt.tight_layout()
frameAndSave(abf,"AP shape")
plt.close('all')
|
def proto_0111(theABF):
"""protocol: IC ramp for AP shape analysis."""
abf=ABF(theABF)
abf.log.info("analyzing as an IC ramp")
# AP detection
ap=AP(abf)
ap.detect()
# also calculate derivative for each sweep
abf.derivative=True
# create the multi-plot figure
plt.figure(figsize=(SQUARESIZE,SQUARESIZE))
ax1=plt.subplot(221)
plt.ylabel(abf.units2)
ax2=plt.subplot(222,sharey=ax1)
ax3=plt.subplot(223)
plt.ylabel(abf.unitsD2)
ax4=plt.subplot(224,sharey=ax3)
# put data in each subplot
for sweep in range(abf.sweeps):
abf.setsweep(sweep)
ax1.plot(abf.sweepX,abf.sweepY,color='b',lw=.25)
ax2.plot(abf.sweepX,abf.sweepY,color='b')
ax3.plot(abf.sweepX,abf.sweepD,color='r',lw=.25)
ax4.plot(abf.sweepX,abf.sweepD,color='r')
# modify axis
for ax in [ax1,ax2,ax3,ax4]: # everything
ax.margins(0,.1)
ax.grid(alpha=.5)
for ax in [ax3,ax4]: # only derivative APs
ax.axhline(-100,color='r',alpha=.5,ls="--",lw=2)
for ax in [ax2,ax4]: # only zoomed in APs
ax.get_yaxis().set_visible(False)
if len(ap.APs):
firstAP=ap.APs[0]["T"]
ax2.axis([firstAP-.25,firstAP+.25,None,None])
ax4.axis([firstAP-.01,firstAP+.01,None,None])
# show message from first AP
if len(ap.APs):
firstAP=ap.APs[0]
msg="\n".join(["%s = %s"%(x,str(firstAP[x])) for x in sorted(firstAP.keys()) if not "I" in x[-2:]])
plt.subplot(221)
plt.gca().text(0.02, 0.98, msg, transform= plt.gca().transAxes, fontsize=10, verticalalignment='top', family='monospace')
# save it
plt.tight_layout()
frameAndSave(abf,"AP shape")
plt.close('all')
|
[
"protocol",
":",
"IC",
"ramp",
"for",
"AP",
"shape",
"analysis",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/analysis/protocols.py#L82-L134
|
[
"def",
"proto_0111",
"(",
"theABF",
")",
":",
"abf",
"=",
"ABF",
"(",
"theABF",
")",
"abf",
".",
"log",
".",
"info",
"(",
"\"analyzing as an IC ramp\"",
")",
"# AP detection",
"ap",
"=",
"AP",
"(",
"abf",
")",
"ap",
".",
"detect",
"(",
")",
"# also calculate derivative for each sweep",
"abf",
".",
"derivative",
"=",
"True",
"# create the multi-plot figure",
"plt",
".",
"figure",
"(",
"figsize",
"=",
"(",
"SQUARESIZE",
",",
"SQUARESIZE",
")",
")",
"ax1",
"=",
"plt",
".",
"subplot",
"(",
"221",
")",
"plt",
".",
"ylabel",
"(",
"abf",
".",
"units2",
")",
"ax2",
"=",
"plt",
".",
"subplot",
"(",
"222",
",",
"sharey",
"=",
"ax1",
")",
"ax3",
"=",
"plt",
".",
"subplot",
"(",
"223",
")",
"plt",
".",
"ylabel",
"(",
"abf",
".",
"unitsD2",
")",
"ax4",
"=",
"plt",
".",
"subplot",
"(",
"224",
",",
"sharey",
"=",
"ax3",
")",
"# put data in each subplot",
"for",
"sweep",
"in",
"range",
"(",
"abf",
".",
"sweeps",
")",
":",
"abf",
".",
"setsweep",
"(",
"sweep",
")",
"ax1",
".",
"plot",
"(",
"abf",
".",
"sweepX",
",",
"abf",
".",
"sweepY",
",",
"color",
"=",
"'b'",
",",
"lw",
"=",
".25",
")",
"ax2",
".",
"plot",
"(",
"abf",
".",
"sweepX",
",",
"abf",
".",
"sweepY",
",",
"color",
"=",
"'b'",
")",
"ax3",
".",
"plot",
"(",
"abf",
".",
"sweepX",
",",
"abf",
".",
"sweepD",
",",
"color",
"=",
"'r'",
",",
"lw",
"=",
".25",
")",
"ax4",
".",
"plot",
"(",
"abf",
".",
"sweepX",
",",
"abf",
".",
"sweepD",
",",
"color",
"=",
"'r'",
")",
"# modify axis",
"for",
"ax",
"in",
"[",
"ax1",
",",
"ax2",
",",
"ax3",
",",
"ax4",
"]",
":",
"# everything",
"ax",
".",
"margins",
"(",
"0",
",",
".1",
")",
"ax",
".",
"grid",
"(",
"alpha",
"=",
".5",
")",
"for",
"ax",
"in",
"[",
"ax3",
",",
"ax4",
"]",
":",
"# only derivative APs",
"ax",
".",
"axhline",
"(",
"-",
"100",
",",
"color",
"=",
"'r'",
",",
"alpha",
"=",
".5",
",",
"ls",
"=",
"\"--\"",
",",
"lw",
"=",
"2",
")",
"for",
"ax",
"in",
"[",
"ax2",
",",
"ax4",
"]",
":",
"# only zoomed in APs",
"ax",
".",
"get_yaxis",
"(",
")",
".",
"set_visible",
"(",
"False",
")",
"if",
"len",
"(",
"ap",
".",
"APs",
")",
":",
"firstAP",
"=",
"ap",
".",
"APs",
"[",
"0",
"]",
"[",
"\"T\"",
"]",
"ax2",
".",
"axis",
"(",
"[",
"firstAP",
"-",
".25",
",",
"firstAP",
"+",
".25",
",",
"None",
",",
"None",
"]",
")",
"ax4",
".",
"axis",
"(",
"[",
"firstAP",
"-",
".01",
",",
"firstAP",
"+",
".01",
",",
"None",
",",
"None",
"]",
")",
"# show message from first AP",
"if",
"len",
"(",
"ap",
".",
"APs",
")",
":",
"firstAP",
"=",
"ap",
".",
"APs",
"[",
"0",
"]",
"msg",
"=",
"\"\\n\"",
".",
"join",
"(",
"[",
"\"%s = %s\"",
"%",
"(",
"x",
",",
"str",
"(",
"firstAP",
"[",
"x",
"]",
")",
")",
"for",
"x",
"in",
"sorted",
"(",
"firstAP",
".",
"keys",
"(",
")",
")",
"if",
"not",
"\"I\"",
"in",
"x",
"[",
"-",
"2",
":",
"]",
"]",
")",
"plt",
".",
"subplot",
"(",
"221",
")",
"plt",
".",
"gca",
"(",
")",
".",
"text",
"(",
"0.02",
",",
"0.98",
",",
"msg",
",",
"transform",
"=",
"plt",
".",
"gca",
"(",
")",
".",
"transAxes",
",",
"fontsize",
"=",
"10",
",",
"verticalalignment",
"=",
"'top'",
",",
"family",
"=",
"'monospace'",
")",
"# save it",
"plt",
".",
"tight_layout",
"(",
")",
"frameAndSave",
"(",
"abf",
",",
"\"AP shape\"",
")",
"plt",
".",
"close",
"(",
"'all'",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
proto_gain
|
protocol: gain function of some sort. step size and start at are pA.
|
swhlab/analysis/protocols.py
|
def proto_gain(theABF,stepSize=25,startAt=-100):
"""protocol: gain function of some sort. step size and start at are pA."""
abf=ABF(theABF)
abf.log.info("analyzing as an IC ramp")
plot=ABFplot(abf)
plot.kwargs["lw"]=.5
plot.title=""
currents=np.arange(abf.sweeps)*stepSize-startAt
# AP detection
ap=AP(abf)
ap.detect_time1=.1
ap.detect_time2=.7
ap.detect()
# stacked plot
plt.figure(figsize=(SQUARESIZE,SQUARESIZE))
ax1=plt.subplot(221)
plot.figure_sweeps()
ax2=plt.subplot(222)
ax2.get_yaxis().set_visible(False)
plot.figure_sweeps(offsetY=150)
# add vertical marks to graphs:
for ax in [ax1,ax2]:
for limit in [ap.detect_time1,ap.detect_time2]:
ax.axvline(limit,color='r',ls='--',alpha=.5,lw=2)
# make stacked gain function
ax4=plt.subplot(223)
plt.ylabel("frequency (Hz)")
plt.ylabel("seconds")
plt.grid(alpha=.5)
freqs=ap.get_bySweep("freqs")
times=ap.get_bySweep("times")
for i in range(abf.sweeps):
if len(freqs[i]):
plt.plot(times[i][:-1],freqs[i],'-',alpha=.5,lw=2,
color=plot.getColor(i/abf.sweeps))
# make gain function graph
ax4=plt.subplot(224)
ax4.grid(alpha=.5)
plt.plot(currents,ap.get_bySweep("median"),'b.-',label="median")
plt.plot(currents,ap.get_bySweep("firsts"),'g.-',label="first")
plt.xlabel("applied current (pA)")
plt.legend(loc=2,fontsize=10)
plt.axhline(40,color='r',alpha=.5,ls="--",lw=2)
plt.margins(.02,.1)
# save it
plt.tight_layout()
frameAndSave(abf,"AP Gain %d_%d"%(startAt,stepSize))
plt.close('all')
# make a second figure that just shows every sweep up to the first AP
plt.figure(figsize=(SQUARESIZE,SQUARESIZE))
plt.grid(alpha=.5)
plt.ylabel("Membrane Potential (mV)")
plt.xlabel("Time (seconds)")
for sweep in abf.setsweeps():
plt.plot(abf.sweepX2,abf.sweepY,color='b',alpha=.5)
if np.max(abf.sweepY>0):
break
plt.tight_layout()
plt.margins(0,.1)
plt.axis([0,1,None,None])
plt.title("%d pA Steps from Rest"%stepSize)
frameAndSave(abf,"voltage response fromRest",closeWhenDone=False)
plt.axis([1.5,2.5,None,None])
plt.title("%d pA Steps from %d pA"%(stepSize,startAt))
frameAndSave(abf,"voltage response hyperpol",closeWhenDone=False)
plt.close('all')
|
def proto_gain(theABF,stepSize=25,startAt=-100):
"""protocol: gain function of some sort. step size and start at are pA."""
abf=ABF(theABF)
abf.log.info("analyzing as an IC ramp")
plot=ABFplot(abf)
plot.kwargs["lw"]=.5
plot.title=""
currents=np.arange(abf.sweeps)*stepSize-startAt
# AP detection
ap=AP(abf)
ap.detect_time1=.1
ap.detect_time2=.7
ap.detect()
# stacked plot
plt.figure(figsize=(SQUARESIZE,SQUARESIZE))
ax1=plt.subplot(221)
plot.figure_sweeps()
ax2=plt.subplot(222)
ax2.get_yaxis().set_visible(False)
plot.figure_sweeps(offsetY=150)
# add vertical marks to graphs:
for ax in [ax1,ax2]:
for limit in [ap.detect_time1,ap.detect_time2]:
ax.axvline(limit,color='r',ls='--',alpha=.5,lw=2)
# make stacked gain function
ax4=plt.subplot(223)
plt.ylabel("frequency (Hz)")
plt.ylabel("seconds")
plt.grid(alpha=.5)
freqs=ap.get_bySweep("freqs")
times=ap.get_bySweep("times")
for i in range(abf.sweeps):
if len(freqs[i]):
plt.plot(times[i][:-1],freqs[i],'-',alpha=.5,lw=2,
color=plot.getColor(i/abf.sweeps))
# make gain function graph
ax4=plt.subplot(224)
ax4.grid(alpha=.5)
plt.plot(currents,ap.get_bySweep("median"),'b.-',label="median")
plt.plot(currents,ap.get_bySweep("firsts"),'g.-',label="first")
plt.xlabel("applied current (pA)")
plt.legend(loc=2,fontsize=10)
plt.axhline(40,color='r',alpha=.5,ls="--",lw=2)
plt.margins(.02,.1)
# save it
plt.tight_layout()
frameAndSave(abf,"AP Gain %d_%d"%(startAt,stepSize))
plt.close('all')
# make a second figure that just shows every sweep up to the first AP
plt.figure(figsize=(SQUARESIZE,SQUARESIZE))
plt.grid(alpha=.5)
plt.ylabel("Membrane Potential (mV)")
plt.xlabel("Time (seconds)")
for sweep in abf.setsweeps():
plt.plot(abf.sweepX2,abf.sweepY,color='b',alpha=.5)
if np.max(abf.sweepY>0):
break
plt.tight_layout()
plt.margins(0,.1)
plt.axis([0,1,None,None])
plt.title("%d pA Steps from Rest"%stepSize)
frameAndSave(abf,"voltage response fromRest",closeWhenDone=False)
plt.axis([1.5,2.5,None,None])
plt.title("%d pA Steps from %d pA"%(stepSize,startAt))
frameAndSave(abf,"voltage response hyperpol",closeWhenDone=False)
plt.close('all')
|
[
"protocol",
":",
"gain",
"function",
"of",
"some",
"sort",
".",
"step",
"size",
"and",
"start",
"at",
"are",
"pA",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/analysis/protocols.py#L136-L211
|
[
"def",
"proto_gain",
"(",
"theABF",
",",
"stepSize",
"=",
"25",
",",
"startAt",
"=",
"-",
"100",
")",
":",
"abf",
"=",
"ABF",
"(",
"theABF",
")",
"abf",
".",
"log",
".",
"info",
"(",
"\"analyzing as an IC ramp\"",
")",
"plot",
"=",
"ABFplot",
"(",
"abf",
")",
"plot",
".",
"kwargs",
"[",
"\"lw\"",
"]",
"=",
".5",
"plot",
".",
"title",
"=",
"\"\"",
"currents",
"=",
"np",
".",
"arange",
"(",
"abf",
".",
"sweeps",
")",
"*",
"stepSize",
"-",
"startAt",
"# AP detection",
"ap",
"=",
"AP",
"(",
"abf",
")",
"ap",
".",
"detect_time1",
"=",
".1",
"ap",
".",
"detect_time2",
"=",
".7",
"ap",
".",
"detect",
"(",
")",
"# stacked plot",
"plt",
".",
"figure",
"(",
"figsize",
"=",
"(",
"SQUARESIZE",
",",
"SQUARESIZE",
")",
")",
"ax1",
"=",
"plt",
".",
"subplot",
"(",
"221",
")",
"plot",
".",
"figure_sweeps",
"(",
")",
"ax2",
"=",
"plt",
".",
"subplot",
"(",
"222",
")",
"ax2",
".",
"get_yaxis",
"(",
")",
".",
"set_visible",
"(",
"False",
")",
"plot",
".",
"figure_sweeps",
"(",
"offsetY",
"=",
"150",
")",
"# add vertical marks to graphs:",
"for",
"ax",
"in",
"[",
"ax1",
",",
"ax2",
"]",
":",
"for",
"limit",
"in",
"[",
"ap",
".",
"detect_time1",
",",
"ap",
".",
"detect_time2",
"]",
":",
"ax",
".",
"axvline",
"(",
"limit",
",",
"color",
"=",
"'r'",
",",
"ls",
"=",
"'--'",
",",
"alpha",
"=",
".5",
",",
"lw",
"=",
"2",
")",
"# make stacked gain function",
"ax4",
"=",
"plt",
".",
"subplot",
"(",
"223",
")",
"plt",
".",
"ylabel",
"(",
"\"frequency (Hz)\"",
")",
"plt",
".",
"ylabel",
"(",
"\"seconds\"",
")",
"plt",
".",
"grid",
"(",
"alpha",
"=",
".5",
")",
"freqs",
"=",
"ap",
".",
"get_bySweep",
"(",
"\"freqs\"",
")",
"times",
"=",
"ap",
".",
"get_bySweep",
"(",
"\"times\"",
")",
"for",
"i",
"in",
"range",
"(",
"abf",
".",
"sweeps",
")",
":",
"if",
"len",
"(",
"freqs",
"[",
"i",
"]",
")",
":",
"plt",
".",
"plot",
"(",
"times",
"[",
"i",
"]",
"[",
":",
"-",
"1",
"]",
",",
"freqs",
"[",
"i",
"]",
",",
"'-'",
",",
"alpha",
"=",
".5",
",",
"lw",
"=",
"2",
",",
"color",
"=",
"plot",
".",
"getColor",
"(",
"i",
"/",
"abf",
".",
"sweeps",
")",
")",
"# make gain function graph",
"ax4",
"=",
"plt",
".",
"subplot",
"(",
"224",
")",
"ax4",
".",
"grid",
"(",
"alpha",
"=",
".5",
")",
"plt",
".",
"plot",
"(",
"currents",
",",
"ap",
".",
"get_bySweep",
"(",
"\"median\"",
")",
",",
"'b.-'",
",",
"label",
"=",
"\"median\"",
")",
"plt",
".",
"plot",
"(",
"currents",
",",
"ap",
".",
"get_bySweep",
"(",
"\"firsts\"",
")",
",",
"'g.-'",
",",
"label",
"=",
"\"first\"",
")",
"plt",
".",
"xlabel",
"(",
"\"applied current (pA)\"",
")",
"plt",
".",
"legend",
"(",
"loc",
"=",
"2",
",",
"fontsize",
"=",
"10",
")",
"plt",
".",
"axhline",
"(",
"40",
",",
"color",
"=",
"'r'",
",",
"alpha",
"=",
".5",
",",
"ls",
"=",
"\"--\"",
",",
"lw",
"=",
"2",
")",
"plt",
".",
"margins",
"(",
".02",
",",
".1",
")",
"# save it",
"plt",
".",
"tight_layout",
"(",
")",
"frameAndSave",
"(",
"abf",
",",
"\"AP Gain %d_%d\"",
"%",
"(",
"startAt",
",",
"stepSize",
")",
")",
"plt",
".",
"close",
"(",
"'all'",
")",
"# make a second figure that just shows every sweep up to the first AP",
"plt",
".",
"figure",
"(",
"figsize",
"=",
"(",
"SQUARESIZE",
",",
"SQUARESIZE",
")",
")",
"plt",
".",
"grid",
"(",
"alpha",
"=",
".5",
")",
"plt",
".",
"ylabel",
"(",
"\"Membrane Potential (mV)\"",
")",
"plt",
".",
"xlabel",
"(",
"\"Time (seconds)\"",
")",
"for",
"sweep",
"in",
"abf",
".",
"setsweeps",
"(",
")",
":",
"plt",
".",
"plot",
"(",
"abf",
".",
"sweepX2",
",",
"abf",
".",
"sweepY",
",",
"color",
"=",
"'b'",
",",
"alpha",
"=",
".5",
")",
"if",
"np",
".",
"max",
"(",
"abf",
".",
"sweepY",
">",
"0",
")",
":",
"break",
"plt",
".",
"tight_layout",
"(",
")",
"plt",
".",
"margins",
"(",
"0",
",",
".1",
")",
"plt",
".",
"axis",
"(",
"[",
"0",
",",
"1",
",",
"None",
",",
"None",
"]",
")",
"plt",
".",
"title",
"(",
"\"%d pA Steps from Rest\"",
"%",
"stepSize",
")",
"frameAndSave",
"(",
"abf",
",",
"\"voltage response fromRest\"",
",",
"closeWhenDone",
"=",
"False",
")",
"plt",
".",
"axis",
"(",
"[",
"1.5",
",",
"2.5",
",",
"None",
",",
"None",
"]",
")",
"plt",
".",
"title",
"(",
"\"%d pA Steps from %d pA\"",
"%",
"(",
"stepSize",
",",
"startAt",
")",
")",
"frameAndSave",
"(",
"abf",
",",
"\"voltage response hyperpol\"",
",",
"closeWhenDone",
"=",
"False",
")",
"plt",
".",
"close",
"(",
"'all'",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
proto_0201
|
protocol: membrane test.
|
swhlab/analysis/protocols.py
|
def proto_0201(theABF):
"""protocol: membrane test."""
abf=ABF(theABF)
abf.log.info("analyzing as a membrane test")
plot=ABFplot(abf)
plot.figure_height,plot.figure_width=SQUARESIZE/2,SQUARESIZE/2
plot.figure_sweeps()
# save it
plt.tight_layout()
frameAndSave(abf,"membrane test")
plt.close('all')
|
def proto_0201(theABF):
"""protocol: membrane test."""
abf=ABF(theABF)
abf.log.info("analyzing as a membrane test")
plot=ABFplot(abf)
plot.figure_height,plot.figure_width=SQUARESIZE/2,SQUARESIZE/2
plot.figure_sweeps()
# save it
plt.tight_layout()
frameAndSave(abf,"membrane test")
plt.close('all')
|
[
"protocol",
":",
"membrane",
"test",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/analysis/protocols.py#L225-L236
|
[
"def",
"proto_0201",
"(",
"theABF",
")",
":",
"abf",
"=",
"ABF",
"(",
"theABF",
")",
"abf",
".",
"log",
".",
"info",
"(",
"\"analyzing as a membrane test\"",
")",
"plot",
"=",
"ABFplot",
"(",
"abf",
")",
"plot",
".",
"figure_height",
",",
"plot",
".",
"figure_width",
"=",
"SQUARESIZE",
"/",
"2",
",",
"SQUARESIZE",
"/",
"2",
"plot",
".",
"figure_sweeps",
"(",
")",
"# save it",
"plt",
".",
"tight_layout",
"(",
")",
"frameAndSave",
"(",
"abf",
",",
"\"membrane test\"",
")",
"plt",
".",
"close",
"(",
"'all'",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
proto_0202
|
protocol: MTIV.
|
swhlab/analysis/protocols.py
|
def proto_0202(theABF):
"""protocol: MTIV."""
abf=ABF(theABF)
abf.log.info("analyzing as MTIV")
plot=ABFplot(abf)
plot.figure_height,plot.figure_width=SQUARESIZE,SQUARESIZE
plot.title=""
plot.kwargs["alpha"]=.6
plot.figure_sweeps()
# frame to uppwer/lower bounds, ignoring peaks from capacitive transients
abf.setsweep(0)
plt.axis([None,None,abf.average(.9,1)-100,None])
abf.setsweep(-1)
plt.axis([None,None,None,abf.average(.9,1)+100])
# save it
plt.tight_layout()
frameAndSave(abf,"MTIV")
plt.close('all')
|
def proto_0202(theABF):
"""protocol: MTIV."""
abf=ABF(theABF)
abf.log.info("analyzing as MTIV")
plot=ABFplot(abf)
plot.figure_height,plot.figure_width=SQUARESIZE,SQUARESIZE
plot.title=""
plot.kwargs["alpha"]=.6
plot.figure_sweeps()
# frame to uppwer/lower bounds, ignoring peaks from capacitive transients
abf.setsweep(0)
plt.axis([None,None,abf.average(.9,1)-100,None])
abf.setsweep(-1)
plt.axis([None,None,None,abf.average(.9,1)+100])
# save it
plt.tight_layout()
frameAndSave(abf,"MTIV")
plt.close('all')
|
[
"protocol",
":",
"MTIV",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/analysis/protocols.py#L238-L257
|
[
"def",
"proto_0202",
"(",
"theABF",
")",
":",
"abf",
"=",
"ABF",
"(",
"theABF",
")",
"abf",
".",
"log",
".",
"info",
"(",
"\"analyzing as MTIV\"",
")",
"plot",
"=",
"ABFplot",
"(",
"abf",
")",
"plot",
".",
"figure_height",
",",
"plot",
".",
"figure_width",
"=",
"SQUARESIZE",
",",
"SQUARESIZE",
"plot",
".",
"title",
"=",
"\"\"",
"plot",
".",
"kwargs",
"[",
"\"alpha\"",
"]",
"=",
".6",
"plot",
".",
"figure_sweeps",
"(",
")",
"# frame to uppwer/lower bounds, ignoring peaks from capacitive transients",
"abf",
".",
"setsweep",
"(",
"0",
")",
"plt",
".",
"axis",
"(",
"[",
"None",
",",
"None",
",",
"abf",
".",
"average",
"(",
".9",
",",
"1",
")",
"-",
"100",
",",
"None",
"]",
")",
"abf",
".",
"setsweep",
"(",
"-",
"1",
")",
"plt",
".",
"axis",
"(",
"[",
"None",
",",
"None",
",",
"None",
",",
"abf",
".",
"average",
"(",
".9",
",",
"1",
")",
"+",
"100",
"]",
")",
"# save it",
"plt",
".",
"tight_layout",
"(",
")",
"frameAndSave",
"(",
"abf",
",",
"\"MTIV\"",
")",
"plt",
".",
"close",
"(",
"'all'",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
proto_0203
|
protocol: vast IV.
|
swhlab/analysis/protocols.py
|
def proto_0203(theABF):
"""protocol: vast IV."""
abf=ABF(theABF)
abf.log.info("analyzing as a fast IV")
plot=ABFplot(abf)
plot.title=""
m1,m2=.7,1
plt.figure(figsize=(SQUARESIZE,SQUARESIZE/2))
plt.subplot(121)
plot.figure_sweeps()
plt.axvspan(m1,m2,color='r',ec=None,alpha=.1)
plt.subplot(122)
plt.grid(alpha=.5)
Xs=np.arange(abf.sweeps)*5-110
Ys=[]
for sweep in range(abf.sweeps):
abf.setsweep(sweep)
Ys.append(abf.average(m1,m2))
plt.plot(Xs,Ys,'.-',ms=10)
plt.axvline(-70,color='r',ls='--',lw=2,alpha=.5)
plt.axhline(0,color='r',ls='--',lw=2,alpha=.5)
plt.margins(.1,.1)
plt.xlabel("membrane potential (mV)")
# save it
plt.tight_layout()
frameAndSave(abf,"fast IV")
plt.close('all')
|
def proto_0203(theABF):
"""protocol: vast IV."""
abf=ABF(theABF)
abf.log.info("analyzing as a fast IV")
plot=ABFplot(abf)
plot.title=""
m1,m2=.7,1
plt.figure(figsize=(SQUARESIZE,SQUARESIZE/2))
plt.subplot(121)
plot.figure_sweeps()
plt.axvspan(m1,m2,color='r',ec=None,alpha=.1)
plt.subplot(122)
plt.grid(alpha=.5)
Xs=np.arange(abf.sweeps)*5-110
Ys=[]
for sweep in range(abf.sweeps):
abf.setsweep(sweep)
Ys.append(abf.average(m1,m2))
plt.plot(Xs,Ys,'.-',ms=10)
plt.axvline(-70,color='r',ls='--',lw=2,alpha=.5)
plt.axhline(0,color='r',ls='--',lw=2,alpha=.5)
plt.margins(.1,.1)
plt.xlabel("membrane potential (mV)")
# save it
plt.tight_layout()
frameAndSave(abf,"fast IV")
plt.close('all')
|
[
"protocol",
":",
"vast",
"IV",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/analysis/protocols.py#L259-L288
|
[
"def",
"proto_0203",
"(",
"theABF",
")",
":",
"abf",
"=",
"ABF",
"(",
"theABF",
")",
"abf",
".",
"log",
".",
"info",
"(",
"\"analyzing as a fast IV\"",
")",
"plot",
"=",
"ABFplot",
"(",
"abf",
")",
"plot",
".",
"title",
"=",
"\"\"",
"m1",
",",
"m2",
"=",
".7",
",",
"1",
"plt",
".",
"figure",
"(",
"figsize",
"=",
"(",
"SQUARESIZE",
",",
"SQUARESIZE",
"/",
"2",
")",
")",
"plt",
".",
"subplot",
"(",
"121",
")",
"plot",
".",
"figure_sweeps",
"(",
")",
"plt",
".",
"axvspan",
"(",
"m1",
",",
"m2",
",",
"color",
"=",
"'r'",
",",
"ec",
"=",
"None",
",",
"alpha",
"=",
".1",
")",
"plt",
".",
"subplot",
"(",
"122",
")",
"plt",
".",
"grid",
"(",
"alpha",
"=",
".5",
")",
"Xs",
"=",
"np",
".",
"arange",
"(",
"abf",
".",
"sweeps",
")",
"*",
"5",
"-",
"110",
"Ys",
"=",
"[",
"]",
"for",
"sweep",
"in",
"range",
"(",
"abf",
".",
"sweeps",
")",
":",
"abf",
".",
"setsweep",
"(",
"sweep",
")",
"Ys",
".",
"append",
"(",
"abf",
".",
"average",
"(",
"m1",
",",
"m2",
")",
")",
"plt",
".",
"plot",
"(",
"Xs",
",",
"Ys",
",",
"'.-'",
",",
"ms",
"=",
"10",
")",
"plt",
".",
"axvline",
"(",
"-",
"70",
",",
"color",
"=",
"'r'",
",",
"ls",
"=",
"'--'",
",",
"lw",
"=",
"2",
",",
"alpha",
"=",
".5",
")",
"plt",
".",
"axhline",
"(",
"0",
",",
"color",
"=",
"'r'",
",",
"ls",
"=",
"'--'",
",",
"lw",
"=",
"2",
",",
"alpha",
"=",
".5",
")",
"plt",
".",
"margins",
"(",
".1",
",",
".1",
")",
"plt",
".",
"xlabel",
"(",
"\"membrane potential (mV)\"",
")",
"# save it",
"plt",
".",
"tight_layout",
"(",
")",
"frameAndSave",
"(",
"abf",
",",
"\"fast IV\"",
")",
"plt",
".",
"close",
"(",
"'all'",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
proto_0303
|
protocol: repeated IC ramps.
|
swhlab/analysis/protocols.py
|
def proto_0303(theABF):
"""protocol: repeated IC ramps."""
abf=ABF(theABF)
abf.log.info("analyzing as a halorhodopsin (2s pulse)")
# show average voltage
proto_avgRange(theABF,0.2,1.2)
plt.close('all')
# show stacked sweeps
plt.figure(figsize=(8,8))
for sweep in abf.setsweeps():
color='b'
if sweep in np.array(abf.comment_sweeps,dtype=int):
color='r'
plt.plot(abf.sweepX2,abf.sweepY+100*sweep,color=color,alpha=.5)
plt.margins(0,.01)
plt.tight_layout()
frameAndSave(abf,"IC ramps")
plt.close('all')
# do AP event detection
ap=AP(abf)
ap.detect_time1=2.3
ap.detect_time2=8.3
ap.detect()
apCount=[]
apSweepTimes=[]
for sweepNumber,times in enumerate(ap.get_bySweep("times")):
apCount.append(len(times))
if len(times):
apSweepTimes.append(times[0])
else:
apSweepTimes.append(0)
# plot AP frequency vs time
plt.figure(figsize=(8,8))
ax1=plt.subplot(211)
plt.grid(alpha=.4,ls='--')
plt.plot(np.arange(len(apCount))*abf.sweepLength/60,apCount,'.-',ms=15)
comment_lines(abf)
plt.ylabel("AP Count")
plt.subplot(212,sharex=ax1)
plt.grid(alpha=.4,ls='--')
plt.plot(np.arange(len(apCount))*abf.sweepLength/60,apSweepTimes,'.-',ms=15)
comment_lines(abf)
plt.ylabel("First AP Time (s)")
plt.xlabel("Experiment Duration (minutes)")
plt.tight_layout()
frameAndSave(abf,"IC ramp freq")
plt.close('all')
|
def proto_0303(theABF):
"""protocol: repeated IC ramps."""
abf=ABF(theABF)
abf.log.info("analyzing as a halorhodopsin (2s pulse)")
# show average voltage
proto_avgRange(theABF,0.2,1.2)
plt.close('all')
# show stacked sweeps
plt.figure(figsize=(8,8))
for sweep in abf.setsweeps():
color='b'
if sweep in np.array(abf.comment_sweeps,dtype=int):
color='r'
plt.plot(abf.sweepX2,abf.sweepY+100*sweep,color=color,alpha=.5)
plt.margins(0,.01)
plt.tight_layout()
frameAndSave(abf,"IC ramps")
plt.close('all')
# do AP event detection
ap=AP(abf)
ap.detect_time1=2.3
ap.detect_time2=8.3
ap.detect()
apCount=[]
apSweepTimes=[]
for sweepNumber,times in enumerate(ap.get_bySweep("times")):
apCount.append(len(times))
if len(times):
apSweepTimes.append(times[0])
else:
apSweepTimes.append(0)
# plot AP frequency vs time
plt.figure(figsize=(8,8))
ax1=plt.subplot(211)
plt.grid(alpha=.4,ls='--')
plt.plot(np.arange(len(apCount))*abf.sweepLength/60,apCount,'.-',ms=15)
comment_lines(abf)
plt.ylabel("AP Count")
plt.subplot(212,sharex=ax1)
plt.grid(alpha=.4,ls='--')
plt.plot(np.arange(len(apCount))*abf.sweepLength/60,apSweepTimes,'.-',ms=15)
comment_lines(abf)
plt.ylabel("First AP Time (s)")
plt.xlabel("Experiment Duration (minutes)")
plt.tight_layout()
frameAndSave(abf,"IC ramp freq")
plt.close('all')
|
[
"protocol",
":",
"repeated",
"IC",
"ramps",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/analysis/protocols.py#L316-L370
|
[
"def",
"proto_0303",
"(",
"theABF",
")",
":",
"abf",
"=",
"ABF",
"(",
"theABF",
")",
"abf",
".",
"log",
".",
"info",
"(",
"\"analyzing as a halorhodopsin (2s pulse)\"",
")",
"# show average voltage",
"proto_avgRange",
"(",
"theABF",
",",
"0.2",
",",
"1.2",
")",
"plt",
".",
"close",
"(",
"'all'",
")",
"# show stacked sweeps",
"plt",
".",
"figure",
"(",
"figsize",
"=",
"(",
"8",
",",
"8",
")",
")",
"for",
"sweep",
"in",
"abf",
".",
"setsweeps",
"(",
")",
":",
"color",
"=",
"'b'",
"if",
"sweep",
"in",
"np",
".",
"array",
"(",
"abf",
".",
"comment_sweeps",
",",
"dtype",
"=",
"int",
")",
":",
"color",
"=",
"'r'",
"plt",
".",
"plot",
"(",
"abf",
".",
"sweepX2",
",",
"abf",
".",
"sweepY",
"+",
"100",
"*",
"sweep",
",",
"color",
"=",
"color",
",",
"alpha",
"=",
".5",
")",
"plt",
".",
"margins",
"(",
"0",
",",
".01",
")",
"plt",
".",
"tight_layout",
"(",
")",
"frameAndSave",
"(",
"abf",
",",
"\"IC ramps\"",
")",
"plt",
".",
"close",
"(",
"'all'",
")",
"# do AP event detection",
"ap",
"=",
"AP",
"(",
"abf",
")",
"ap",
".",
"detect_time1",
"=",
"2.3",
"ap",
".",
"detect_time2",
"=",
"8.3",
"ap",
".",
"detect",
"(",
")",
"apCount",
"=",
"[",
"]",
"apSweepTimes",
"=",
"[",
"]",
"for",
"sweepNumber",
",",
"times",
"in",
"enumerate",
"(",
"ap",
".",
"get_bySweep",
"(",
"\"times\"",
")",
")",
":",
"apCount",
".",
"append",
"(",
"len",
"(",
"times",
")",
")",
"if",
"len",
"(",
"times",
")",
":",
"apSweepTimes",
".",
"append",
"(",
"times",
"[",
"0",
"]",
")",
"else",
":",
"apSweepTimes",
".",
"append",
"(",
"0",
")",
"# plot AP frequency vs time",
"plt",
".",
"figure",
"(",
"figsize",
"=",
"(",
"8",
",",
"8",
")",
")",
"ax1",
"=",
"plt",
".",
"subplot",
"(",
"211",
")",
"plt",
".",
"grid",
"(",
"alpha",
"=",
".4",
",",
"ls",
"=",
"'--'",
")",
"plt",
".",
"plot",
"(",
"np",
".",
"arange",
"(",
"len",
"(",
"apCount",
")",
")",
"*",
"abf",
".",
"sweepLength",
"/",
"60",
",",
"apCount",
",",
"'.-'",
",",
"ms",
"=",
"15",
")",
"comment_lines",
"(",
"abf",
")",
"plt",
".",
"ylabel",
"(",
"\"AP Count\"",
")",
"plt",
".",
"subplot",
"(",
"212",
",",
"sharex",
"=",
"ax1",
")",
"plt",
".",
"grid",
"(",
"alpha",
"=",
".4",
",",
"ls",
"=",
"'--'",
")",
"plt",
".",
"plot",
"(",
"np",
".",
"arange",
"(",
"len",
"(",
"apCount",
")",
")",
"*",
"abf",
".",
"sweepLength",
"/",
"60",
",",
"apSweepTimes",
",",
"'.-'",
",",
"ms",
"=",
"15",
")",
"comment_lines",
"(",
"abf",
")",
"plt",
".",
"ylabel",
"(",
"\"First AP Time (s)\"",
")",
"plt",
".",
"xlabel",
"(",
"\"Experiment Duration (minutes)\"",
")",
"plt",
".",
"tight_layout",
"(",
")",
"frameAndSave",
"(",
"abf",
",",
"\"IC ramp freq\"",
")",
"plt",
".",
"close",
"(",
"'all'",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
proto_0304
|
protocol: repeated IC steps.
|
swhlab/analysis/protocols.py
|
def proto_0304(theABF):
"""protocol: repeated IC steps."""
abf=ABF(theABF)
abf.log.info("analyzing as repeated current-clamp step")
# prepare for AP analysis
ap=AP(abf)
# calculate rest potential
avgVoltagePerSweep = [];
times = []
for sweep in abf.setsweeps():
avgVoltagePerSweep.append(abf.average(0,3))
times.append(abf.sweepStart/60)
# detect only step APs
M1,M2=3.15,4.15
ap.detect_time1, ap.detect_time2 = M1,M2
ap.detect()
apsPerSweepCos=[len(x) for x in ap.get_bySweep()]
# detect all APs
M1,M2=0,10
ap.detect_time1, ap.detect_time2 = M1,M2
ap.detect()
apsPerSweepRamp=[len(x) for x in ap.get_bySweep()]
# make the plot of APs and stuff
plt.figure(figsize=(8,8))
plt.subplot(311)
plt.grid(ls='--',alpha=.5)
plt.plot(times,avgVoltagePerSweep,'.-')
plt.ylabel("Rest Potential (mV)")
comment_lines(abf)
plt.subplot(312)
plt.grid(ls='--',alpha=.5)
plt.plot(times,apsPerSweepCos,'.-')
plt.ylabel("APs in Step (#)")
comment_lines(abf)
plt.subplot(313)
plt.grid(ls='--',alpha=.5)
plt.plot(times,apsPerSweepRamp,'.-')
plt.ylabel("APs in Sweep (#)")
comment_lines(abf)
plt.tight_layout()
frameAndSave(abf,"cos ramp")
plt.close('all')
|
def proto_0304(theABF):
"""protocol: repeated IC steps."""
abf=ABF(theABF)
abf.log.info("analyzing as repeated current-clamp step")
# prepare for AP analysis
ap=AP(abf)
# calculate rest potential
avgVoltagePerSweep = [];
times = []
for sweep in abf.setsweeps():
avgVoltagePerSweep.append(abf.average(0,3))
times.append(abf.sweepStart/60)
# detect only step APs
M1,M2=3.15,4.15
ap.detect_time1, ap.detect_time2 = M1,M2
ap.detect()
apsPerSweepCos=[len(x) for x in ap.get_bySweep()]
# detect all APs
M1,M2=0,10
ap.detect_time1, ap.detect_time2 = M1,M2
ap.detect()
apsPerSweepRamp=[len(x) for x in ap.get_bySweep()]
# make the plot of APs and stuff
plt.figure(figsize=(8,8))
plt.subplot(311)
plt.grid(ls='--',alpha=.5)
plt.plot(times,avgVoltagePerSweep,'.-')
plt.ylabel("Rest Potential (mV)")
comment_lines(abf)
plt.subplot(312)
plt.grid(ls='--',alpha=.5)
plt.plot(times,apsPerSweepCos,'.-')
plt.ylabel("APs in Step (#)")
comment_lines(abf)
plt.subplot(313)
plt.grid(ls='--',alpha=.5)
plt.plot(times,apsPerSweepRamp,'.-')
plt.ylabel("APs in Sweep (#)")
comment_lines(abf)
plt.tight_layout()
frameAndSave(abf,"cos ramp")
plt.close('all')
|
[
"protocol",
":",
"repeated",
"IC",
"steps",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/analysis/protocols.py#L372-L424
|
[
"def",
"proto_0304",
"(",
"theABF",
")",
":",
"abf",
"=",
"ABF",
"(",
"theABF",
")",
"abf",
".",
"log",
".",
"info",
"(",
"\"analyzing as repeated current-clamp step\"",
")",
"# prepare for AP analysis",
"ap",
"=",
"AP",
"(",
"abf",
")",
"# calculate rest potential",
"avgVoltagePerSweep",
"=",
"[",
"]",
"times",
"=",
"[",
"]",
"for",
"sweep",
"in",
"abf",
".",
"setsweeps",
"(",
")",
":",
"avgVoltagePerSweep",
".",
"append",
"(",
"abf",
".",
"average",
"(",
"0",
",",
"3",
")",
")",
"times",
".",
"append",
"(",
"abf",
".",
"sweepStart",
"/",
"60",
")",
"# detect only step APs",
"M1",
",",
"M2",
"=",
"3.15",
",",
"4.15",
"ap",
".",
"detect_time1",
",",
"ap",
".",
"detect_time2",
"=",
"M1",
",",
"M2",
"ap",
".",
"detect",
"(",
")",
"apsPerSweepCos",
"=",
"[",
"len",
"(",
"x",
")",
"for",
"x",
"in",
"ap",
".",
"get_bySweep",
"(",
")",
"]",
"# detect all APs",
"M1",
",",
"M2",
"=",
"0",
",",
"10",
"ap",
".",
"detect_time1",
",",
"ap",
".",
"detect_time2",
"=",
"M1",
",",
"M2",
"ap",
".",
"detect",
"(",
")",
"apsPerSweepRamp",
"=",
"[",
"len",
"(",
"x",
")",
"for",
"x",
"in",
"ap",
".",
"get_bySweep",
"(",
")",
"]",
"# make the plot of APs and stuff",
"plt",
".",
"figure",
"(",
"figsize",
"=",
"(",
"8",
",",
"8",
")",
")",
"plt",
".",
"subplot",
"(",
"311",
")",
"plt",
".",
"grid",
"(",
"ls",
"=",
"'--'",
",",
"alpha",
"=",
".5",
")",
"plt",
".",
"plot",
"(",
"times",
",",
"avgVoltagePerSweep",
",",
"'.-'",
")",
"plt",
".",
"ylabel",
"(",
"\"Rest Potential (mV)\"",
")",
"comment_lines",
"(",
"abf",
")",
"plt",
".",
"subplot",
"(",
"312",
")",
"plt",
".",
"grid",
"(",
"ls",
"=",
"'--'",
",",
"alpha",
"=",
".5",
")",
"plt",
".",
"plot",
"(",
"times",
",",
"apsPerSweepCos",
",",
"'.-'",
")",
"plt",
".",
"ylabel",
"(",
"\"APs in Step (#)\"",
")",
"comment_lines",
"(",
"abf",
")",
"plt",
".",
"subplot",
"(",
"313",
")",
"plt",
".",
"grid",
"(",
"ls",
"=",
"'--'",
",",
"alpha",
"=",
".5",
")",
"plt",
".",
"plot",
"(",
"times",
",",
"apsPerSweepRamp",
",",
"'.-'",
")",
"plt",
".",
"ylabel",
"(",
"\"APs in Sweep (#)\"",
")",
"comment_lines",
"(",
"abf",
")",
"plt",
".",
"tight_layout",
"(",
")",
"frameAndSave",
"(",
"abf",
",",
"\"cos ramp\"",
")",
"plt",
".",
"close",
"(",
"'all'",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
proto_avgRange
|
experiment: generic VC time course experiment.
|
swhlab/analysis/protocols.py
|
def proto_avgRange(theABF,m1=None,m2=None):
"""experiment: generic VC time course experiment."""
abf=ABF(theABF)
abf.log.info("analyzing as a fast IV")
if m1 is None:
m1=abf.sweepLength
if m2 is None:
m2=abf.sweepLength
I1=int(abf.pointsPerSec*m1)
I2=int(abf.pointsPerSec*m2)
Ts=np.arange(abf.sweeps)*abf.sweepInterval
Yav=np.empty(abf.sweeps)*np.nan # average
Ysd=np.empty(abf.sweeps)*np.nan # standard deviation
#Yar=np.empty(abf.sweeps)*np.nan # area
for sweep in abf.setsweeps():
Yav[sweep]=np.average(abf.sweepY[I1:I2])
Ysd[sweep]=np.std(abf.sweepY[I1:I2])
#Yar[sweep]=np.sum(abf.sweepY[I1:I2])/(I2*I1)-Yav[sweep]
plot=ABFplot(abf)
plt.figure(figsize=(SQUARESIZE*2,SQUARESIZE/2))
plt.subplot(131)
plot.title="first sweep"
plot.figure_sweep(0)
plt.title("First Sweep\n(shaded measurement range)")
plt.axvspan(m1,m2,color='r',ec=None,alpha=.1)
plt.subplot(132)
plt.grid(alpha=.5)
for i,t in enumerate(abf.comment_times):
plt.axvline(t/60,color='r',alpha=.5,lw=2,ls='--')
plt.plot(Ts/60,Yav,'.',alpha=.75)
plt.title("Range Average\nTAGS: %s"%(", ".join(abf.comment_tags)))
plt.ylabel(abf.units2)
plt.xlabel("minutes")
plt.margins(0,.1)
plt.subplot(133)
plt.grid(alpha=.5)
for i,t in enumerate(abf.comment_times):
plt.axvline(t/60,color='r',alpha=.5,lw=2,ls='--')
plt.plot(Ts/60,Ysd,'.',alpha=.5,color='g',ms=15,mew=0)
#plt.fill_between(Ts/60,Ysd*0,Ysd,lw=0,alpha=.5,color='g')
plt.title("Range Standard Deviation\nTAGS: %s"%(", ".join(abf.comment_tags)))
plt.ylabel(abf.units2)
plt.xlabel("minutes")
plt.margins(0,.1)
plt.axis([None,None,0,np.percentile(Ysd,99)*1.25])
plt.tight_layout()
frameAndSave(abf,"sweep vs average","experiment")
plt.close('all')
|
def proto_avgRange(theABF,m1=None,m2=None):
"""experiment: generic VC time course experiment."""
abf=ABF(theABF)
abf.log.info("analyzing as a fast IV")
if m1 is None:
m1=abf.sweepLength
if m2 is None:
m2=abf.sweepLength
I1=int(abf.pointsPerSec*m1)
I2=int(abf.pointsPerSec*m2)
Ts=np.arange(abf.sweeps)*abf.sweepInterval
Yav=np.empty(abf.sweeps)*np.nan # average
Ysd=np.empty(abf.sweeps)*np.nan # standard deviation
#Yar=np.empty(abf.sweeps)*np.nan # area
for sweep in abf.setsweeps():
Yav[sweep]=np.average(abf.sweepY[I1:I2])
Ysd[sweep]=np.std(abf.sweepY[I1:I2])
#Yar[sweep]=np.sum(abf.sweepY[I1:I2])/(I2*I1)-Yav[sweep]
plot=ABFplot(abf)
plt.figure(figsize=(SQUARESIZE*2,SQUARESIZE/2))
plt.subplot(131)
plot.title="first sweep"
plot.figure_sweep(0)
plt.title("First Sweep\n(shaded measurement range)")
plt.axvspan(m1,m2,color='r',ec=None,alpha=.1)
plt.subplot(132)
plt.grid(alpha=.5)
for i,t in enumerate(abf.comment_times):
plt.axvline(t/60,color='r',alpha=.5,lw=2,ls='--')
plt.plot(Ts/60,Yav,'.',alpha=.75)
plt.title("Range Average\nTAGS: %s"%(", ".join(abf.comment_tags)))
plt.ylabel(abf.units2)
plt.xlabel("minutes")
plt.margins(0,.1)
plt.subplot(133)
plt.grid(alpha=.5)
for i,t in enumerate(abf.comment_times):
plt.axvline(t/60,color='r',alpha=.5,lw=2,ls='--')
plt.plot(Ts/60,Ysd,'.',alpha=.5,color='g',ms=15,mew=0)
#plt.fill_between(Ts/60,Ysd*0,Ysd,lw=0,alpha=.5,color='g')
plt.title("Range Standard Deviation\nTAGS: %s"%(", ".join(abf.comment_tags)))
plt.ylabel(abf.units2)
plt.xlabel("minutes")
plt.margins(0,.1)
plt.axis([None,None,0,np.percentile(Ysd,99)*1.25])
plt.tight_layout()
frameAndSave(abf,"sweep vs average","experiment")
plt.close('all')
|
[
"experiment",
":",
"generic",
"VC",
"time",
"course",
"experiment",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/analysis/protocols.py#L718-L774
|
[
"def",
"proto_avgRange",
"(",
"theABF",
",",
"m1",
"=",
"None",
",",
"m2",
"=",
"None",
")",
":",
"abf",
"=",
"ABF",
"(",
"theABF",
")",
"abf",
".",
"log",
".",
"info",
"(",
"\"analyzing as a fast IV\"",
")",
"if",
"m1",
"is",
"None",
":",
"m1",
"=",
"abf",
".",
"sweepLength",
"if",
"m2",
"is",
"None",
":",
"m2",
"=",
"abf",
".",
"sweepLength",
"I1",
"=",
"int",
"(",
"abf",
".",
"pointsPerSec",
"*",
"m1",
")",
"I2",
"=",
"int",
"(",
"abf",
".",
"pointsPerSec",
"*",
"m2",
")",
"Ts",
"=",
"np",
".",
"arange",
"(",
"abf",
".",
"sweeps",
")",
"*",
"abf",
".",
"sweepInterval",
"Yav",
"=",
"np",
".",
"empty",
"(",
"abf",
".",
"sweeps",
")",
"*",
"np",
".",
"nan",
"# average",
"Ysd",
"=",
"np",
".",
"empty",
"(",
"abf",
".",
"sweeps",
")",
"*",
"np",
".",
"nan",
"# standard deviation",
"#Yar=np.empty(abf.sweeps)*np.nan # area",
"for",
"sweep",
"in",
"abf",
".",
"setsweeps",
"(",
")",
":",
"Yav",
"[",
"sweep",
"]",
"=",
"np",
".",
"average",
"(",
"abf",
".",
"sweepY",
"[",
"I1",
":",
"I2",
"]",
")",
"Ysd",
"[",
"sweep",
"]",
"=",
"np",
".",
"std",
"(",
"abf",
".",
"sweepY",
"[",
"I1",
":",
"I2",
"]",
")",
"#Yar[sweep]=np.sum(abf.sweepY[I1:I2])/(I2*I1)-Yav[sweep]",
"plot",
"=",
"ABFplot",
"(",
"abf",
")",
"plt",
".",
"figure",
"(",
"figsize",
"=",
"(",
"SQUARESIZE",
"*",
"2",
",",
"SQUARESIZE",
"/",
"2",
")",
")",
"plt",
".",
"subplot",
"(",
"131",
")",
"plot",
".",
"title",
"=",
"\"first sweep\"",
"plot",
".",
"figure_sweep",
"(",
"0",
")",
"plt",
".",
"title",
"(",
"\"First Sweep\\n(shaded measurement range)\"",
")",
"plt",
".",
"axvspan",
"(",
"m1",
",",
"m2",
",",
"color",
"=",
"'r'",
",",
"ec",
"=",
"None",
",",
"alpha",
"=",
".1",
")",
"plt",
".",
"subplot",
"(",
"132",
")",
"plt",
".",
"grid",
"(",
"alpha",
"=",
".5",
")",
"for",
"i",
",",
"t",
"in",
"enumerate",
"(",
"abf",
".",
"comment_times",
")",
":",
"plt",
".",
"axvline",
"(",
"t",
"/",
"60",
",",
"color",
"=",
"'r'",
",",
"alpha",
"=",
".5",
",",
"lw",
"=",
"2",
",",
"ls",
"=",
"'--'",
")",
"plt",
".",
"plot",
"(",
"Ts",
"/",
"60",
",",
"Yav",
",",
"'.'",
",",
"alpha",
"=",
".75",
")",
"plt",
".",
"title",
"(",
"\"Range Average\\nTAGS: %s\"",
"%",
"(",
"\", \"",
".",
"join",
"(",
"abf",
".",
"comment_tags",
")",
")",
")",
"plt",
".",
"ylabel",
"(",
"abf",
".",
"units2",
")",
"plt",
".",
"xlabel",
"(",
"\"minutes\"",
")",
"plt",
".",
"margins",
"(",
"0",
",",
".1",
")",
"plt",
".",
"subplot",
"(",
"133",
")",
"plt",
".",
"grid",
"(",
"alpha",
"=",
".5",
")",
"for",
"i",
",",
"t",
"in",
"enumerate",
"(",
"abf",
".",
"comment_times",
")",
":",
"plt",
".",
"axvline",
"(",
"t",
"/",
"60",
",",
"color",
"=",
"'r'",
",",
"alpha",
"=",
".5",
",",
"lw",
"=",
"2",
",",
"ls",
"=",
"'--'",
")",
"plt",
".",
"plot",
"(",
"Ts",
"/",
"60",
",",
"Ysd",
",",
"'.'",
",",
"alpha",
"=",
".5",
",",
"color",
"=",
"'g'",
",",
"ms",
"=",
"15",
",",
"mew",
"=",
"0",
")",
"#plt.fill_between(Ts/60,Ysd*0,Ysd,lw=0,alpha=.5,color='g')",
"plt",
".",
"title",
"(",
"\"Range Standard Deviation\\nTAGS: %s\"",
"%",
"(",
"\", \"",
".",
"join",
"(",
"abf",
".",
"comment_tags",
")",
")",
")",
"plt",
".",
"ylabel",
"(",
"abf",
".",
"units2",
")",
"plt",
".",
"xlabel",
"(",
"\"minutes\"",
")",
"plt",
".",
"margins",
"(",
"0",
",",
".1",
")",
"plt",
".",
"axis",
"(",
"[",
"None",
",",
"None",
",",
"0",
",",
"np",
".",
"percentile",
"(",
"Ysd",
",",
"99",
")",
"*",
"1.25",
"]",
")",
"plt",
".",
"tight_layout",
"(",
")",
"frameAndSave",
"(",
"abf",
",",
"\"sweep vs average\"",
",",
"\"experiment\"",
")",
"plt",
".",
"close",
"(",
"'all'",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
analyze
|
given a filename or ABF object, try to analyze it.
|
swhlab/analysis/protocols.py
|
def analyze(fname=False,save=True,show=None):
"""given a filename or ABF object, try to analyze it."""
if fname and os.path.exists(fname.replace(".abf",".rst")):
print("SKIPPING DUE TO RST FILE")
return
swhlab.plotting.core.IMAGE_SAVE=save
if show is None:
if cm.isIpython():
swhlab.plotting.core.IMAGE_SHOW=True
else:
swhlab.plotting.core.IMAGE_SHOW=False
#swhlab.plotting.core.IMAGE_SHOW=show
abf=ABF(fname) # ensure it's a class
print(">>>>> PROTOCOL >>>>>",abf.protocomment)
runFunction="proto_unknown"
if "proto_"+abf.protocomment in globals():
runFunction="proto_"+abf.protocomment
abf.log.debug("running %s()"%(runFunction))
plt.close('all') # get ready
globals()[runFunction](abf) # run that function
try:
globals()[runFunction](abf) # run that function
except:
abf.log.error("EXCEPTION DURING PROTOCOL FUNCTION")
abf.log.error(sys.exc_info()[0])
return "ERROR"
plt.close('all') # clean up
return "SUCCESS"
|
def analyze(fname=False,save=True,show=None):
"""given a filename or ABF object, try to analyze it."""
if fname and os.path.exists(fname.replace(".abf",".rst")):
print("SKIPPING DUE TO RST FILE")
return
swhlab.plotting.core.IMAGE_SAVE=save
if show is None:
if cm.isIpython():
swhlab.plotting.core.IMAGE_SHOW=True
else:
swhlab.plotting.core.IMAGE_SHOW=False
#swhlab.plotting.core.IMAGE_SHOW=show
abf=ABF(fname) # ensure it's a class
print(">>>>> PROTOCOL >>>>>",abf.protocomment)
runFunction="proto_unknown"
if "proto_"+abf.protocomment in globals():
runFunction="proto_"+abf.protocomment
abf.log.debug("running %s()"%(runFunction))
plt.close('all') # get ready
globals()[runFunction](abf) # run that function
try:
globals()[runFunction](abf) # run that function
except:
abf.log.error("EXCEPTION DURING PROTOCOL FUNCTION")
abf.log.error(sys.exc_info()[0])
return "ERROR"
plt.close('all') # clean up
return "SUCCESS"
|
[
"given",
"a",
"filename",
"or",
"ABF",
"object",
"try",
"to",
"analyze",
"it",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/analysis/protocols.py#L776-L803
|
[
"def",
"analyze",
"(",
"fname",
"=",
"False",
",",
"save",
"=",
"True",
",",
"show",
"=",
"None",
")",
":",
"if",
"fname",
"and",
"os",
".",
"path",
".",
"exists",
"(",
"fname",
".",
"replace",
"(",
"\".abf\"",
",",
"\".rst\"",
")",
")",
":",
"print",
"(",
"\"SKIPPING DUE TO RST FILE\"",
")",
"return",
"swhlab",
".",
"plotting",
".",
"core",
".",
"IMAGE_SAVE",
"=",
"save",
"if",
"show",
"is",
"None",
":",
"if",
"cm",
".",
"isIpython",
"(",
")",
":",
"swhlab",
".",
"plotting",
".",
"core",
".",
"IMAGE_SHOW",
"=",
"True",
"else",
":",
"swhlab",
".",
"plotting",
".",
"core",
".",
"IMAGE_SHOW",
"=",
"False",
"#swhlab.plotting.core.IMAGE_SHOW=show",
"abf",
"=",
"ABF",
"(",
"fname",
")",
"# ensure it's a class",
"print",
"(",
"\">>>>> PROTOCOL >>>>>\"",
",",
"abf",
".",
"protocomment",
")",
"runFunction",
"=",
"\"proto_unknown\"",
"if",
"\"proto_\"",
"+",
"abf",
".",
"protocomment",
"in",
"globals",
"(",
")",
":",
"runFunction",
"=",
"\"proto_\"",
"+",
"abf",
".",
"protocomment",
"abf",
".",
"log",
".",
"debug",
"(",
"\"running %s()\"",
"%",
"(",
"runFunction",
")",
")",
"plt",
".",
"close",
"(",
"'all'",
")",
"# get ready",
"globals",
"(",
")",
"[",
"runFunction",
"]",
"(",
"abf",
")",
"# run that function",
"try",
":",
"globals",
"(",
")",
"[",
"runFunction",
"]",
"(",
"abf",
")",
"# run that function",
"except",
":",
"abf",
".",
"log",
".",
"error",
"(",
"\"EXCEPTION DURING PROTOCOL FUNCTION\"",
")",
"abf",
".",
"log",
".",
"error",
"(",
"sys",
".",
"exc_info",
"(",
")",
"[",
"0",
"]",
")",
"return",
"\"ERROR\"",
"plt",
".",
"close",
"(",
"'all'",
")",
"# clean up",
"return",
"\"SUCCESS\""
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
processFolder
|
call processAbf() for every ABF in a folder.
|
swhlab/analysis/glance.py
|
def processFolder(abfFolder):
"""call processAbf() for every ABF in a folder."""
if not type(abfFolder) is str or not len(abfFolder)>3:
return
files=sorted(glob.glob(abfFolder+"/*.abf"))
for i,fname in enumerate(files):
print("\n\n\n### PROCESSING {} of {}:".format(i,len(files)),os.path.basename(fname))
processAbf(fname,show=False)
plt.show()
return
|
def processFolder(abfFolder):
"""call processAbf() for every ABF in a folder."""
if not type(abfFolder) is str or not len(abfFolder)>3:
return
files=sorted(glob.glob(abfFolder+"/*.abf"))
for i,fname in enumerate(files):
print("\n\n\n### PROCESSING {} of {}:".format(i,len(files)),os.path.basename(fname))
processAbf(fname,show=False)
plt.show()
return
|
[
"call",
"processAbf",
"()",
"for",
"every",
"ABF",
"in",
"a",
"folder",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/analysis/glance.py#L26-L35
|
[
"def",
"processFolder",
"(",
"abfFolder",
")",
":",
"if",
"not",
"type",
"(",
"abfFolder",
")",
"is",
"str",
"or",
"not",
"len",
"(",
"abfFolder",
")",
">",
"3",
":",
"return",
"files",
"=",
"sorted",
"(",
"glob",
".",
"glob",
"(",
"abfFolder",
"+",
"\"/*.abf\"",
")",
")",
"for",
"i",
",",
"fname",
"in",
"enumerate",
"(",
"files",
")",
":",
"print",
"(",
"\"\\n\\n\\n### PROCESSING {} of {}:\"",
".",
"format",
"(",
"i",
",",
"len",
"(",
"files",
")",
")",
",",
"os",
".",
"path",
".",
"basename",
"(",
"fname",
")",
")",
"processAbf",
"(",
"fname",
",",
"show",
"=",
"False",
")",
"plt",
".",
"show",
"(",
")",
"return"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
processAbf
|
automatically generate a single representative image for an ABF.
If saveAs is given (full path of a jpg of png file), the image will be saved.
Otherwise, the image will pop up in a matplotlib window.
|
swhlab/analysis/glance.py
|
def processAbf(abfFname,saveAs=False,dpi=100,show=True):
"""
automatically generate a single representative image for an ABF.
If saveAs is given (full path of a jpg of png file), the image will be saved.
Otherwise, the image will pop up in a matplotlib window.
"""
if not type(abfFname) is str or not len(abfFname)>3:
return
abf=swhlab.ABF(abfFname)
plot=swhlab.plotting.ABFplot(abf)
plot.figure_height=6
plot.figure_width=10
plot.subplot=False
plot.figure(True)
if abf.get_protocol_sequence(0)==abf.get_protocol_sequence(1) or abf.sweeps<2:
# same protocol every time
if abf.lengthMinutes<2:
# short (probably a memtest or tau)
ax1=plt.subplot(211)
plot.figure_sweeps()
plt.title("{} ({} sweeps)".format(abf.ID,abf.sweeps))
plt.gca().get_xaxis().set_visible(False)
plt.subplot(212,sharex=ax1)
plot.figure_protocol()
plt.title("")
else:
# long (probably a drug experiment)
plot.figure_chronological()
else:
# protocol changes every sweep
plots=[211,212] # assume we want 2 images
if abf.units=='mV': # maybe it's something with APs?
ap=swhlab.AP(abf) # go ahead and do AP detection
ap.detect() # try to detect APs
if len(ap.APs): # if we found some
plots=[221,223,222,224] # get ready for 4 images
ax1=plt.subplot(plots[0])
plot.figure_sweeps()
plt.title("{} ({} sweeps)".format(abf.ID,abf.sweeps))
plt.gca().get_xaxis().set_visible(False)
plt.subplot(plots[1],sharex=ax1)
plot.figure_protocols()
plt.title("protocol")
if len(plots)>2:
# assume we want to look at the first AP
ax2=plt.subplot(plots[2])
plot.rainbow=False
plot.kwargs["color"]='b'
plot.figure_chronological()
plt.gca().get_xaxis().set_visible(False)
plt.title("first AP magnitude")
# velocity plot
plt.subplot(plots[3],sharex=ax2)
plot.abf.derivative=True
plot.rainbow=False
plot.traceColor='r'
plot.figure_chronological()
plt.axis([ap.APs[0]["T"]-.05,ap.APs[0]["T"]+.05,None,None])
plt.title("first AP velocity")
if saveAs:
print("saving",os.path.abspath(saveAs))
plt.savefig(os.path.abspath(saveAs),dpi=dpi)
return
if show:
plot.show()
|
def processAbf(abfFname,saveAs=False,dpi=100,show=True):
"""
automatically generate a single representative image for an ABF.
If saveAs is given (full path of a jpg of png file), the image will be saved.
Otherwise, the image will pop up in a matplotlib window.
"""
if not type(abfFname) is str or not len(abfFname)>3:
return
abf=swhlab.ABF(abfFname)
plot=swhlab.plotting.ABFplot(abf)
plot.figure_height=6
plot.figure_width=10
plot.subplot=False
plot.figure(True)
if abf.get_protocol_sequence(0)==abf.get_protocol_sequence(1) or abf.sweeps<2:
# same protocol every time
if abf.lengthMinutes<2:
# short (probably a memtest or tau)
ax1=plt.subplot(211)
plot.figure_sweeps()
plt.title("{} ({} sweeps)".format(abf.ID,abf.sweeps))
plt.gca().get_xaxis().set_visible(False)
plt.subplot(212,sharex=ax1)
plot.figure_protocol()
plt.title("")
else:
# long (probably a drug experiment)
plot.figure_chronological()
else:
# protocol changes every sweep
plots=[211,212] # assume we want 2 images
if abf.units=='mV': # maybe it's something with APs?
ap=swhlab.AP(abf) # go ahead and do AP detection
ap.detect() # try to detect APs
if len(ap.APs): # if we found some
plots=[221,223,222,224] # get ready for 4 images
ax1=plt.subplot(plots[0])
plot.figure_sweeps()
plt.title("{} ({} sweeps)".format(abf.ID,abf.sweeps))
plt.gca().get_xaxis().set_visible(False)
plt.subplot(plots[1],sharex=ax1)
plot.figure_protocols()
plt.title("protocol")
if len(plots)>2:
# assume we want to look at the first AP
ax2=plt.subplot(plots[2])
plot.rainbow=False
plot.kwargs["color"]='b'
plot.figure_chronological()
plt.gca().get_xaxis().set_visible(False)
plt.title("first AP magnitude")
# velocity plot
plt.subplot(plots[3],sharex=ax2)
plot.abf.derivative=True
plot.rainbow=False
plot.traceColor='r'
plot.figure_chronological()
plt.axis([ap.APs[0]["T"]-.05,ap.APs[0]["T"]+.05,None,None])
plt.title("first AP velocity")
if saveAs:
print("saving",os.path.abspath(saveAs))
plt.savefig(os.path.abspath(saveAs),dpi=dpi)
return
if show:
plot.show()
|
[
"automatically",
"generate",
"a",
"single",
"representative",
"image",
"for",
"an",
"ABF",
".",
"If",
"saveAs",
"is",
"given",
"(",
"full",
"path",
"of",
"a",
"jpg",
"of",
"png",
"file",
")",
"the",
"image",
"will",
"be",
"saved",
".",
"Otherwise",
"the",
"image",
"will",
"pop",
"up",
"in",
"a",
"matplotlib",
"window",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/analysis/glance.py#L37-L102
|
[
"def",
"processAbf",
"(",
"abfFname",
",",
"saveAs",
"=",
"False",
",",
"dpi",
"=",
"100",
",",
"show",
"=",
"True",
")",
":",
"if",
"not",
"type",
"(",
"abfFname",
")",
"is",
"str",
"or",
"not",
"len",
"(",
"abfFname",
")",
">",
"3",
":",
"return",
"abf",
"=",
"swhlab",
".",
"ABF",
"(",
"abfFname",
")",
"plot",
"=",
"swhlab",
".",
"plotting",
".",
"ABFplot",
"(",
"abf",
")",
"plot",
".",
"figure_height",
"=",
"6",
"plot",
".",
"figure_width",
"=",
"10",
"plot",
".",
"subplot",
"=",
"False",
"plot",
".",
"figure",
"(",
"True",
")",
"if",
"abf",
".",
"get_protocol_sequence",
"(",
"0",
")",
"==",
"abf",
".",
"get_protocol_sequence",
"(",
"1",
")",
"or",
"abf",
".",
"sweeps",
"<",
"2",
":",
"# same protocol every time",
"if",
"abf",
".",
"lengthMinutes",
"<",
"2",
":",
"# short (probably a memtest or tau)",
"ax1",
"=",
"plt",
".",
"subplot",
"(",
"211",
")",
"plot",
".",
"figure_sweeps",
"(",
")",
"plt",
".",
"title",
"(",
"\"{} ({} sweeps)\"",
".",
"format",
"(",
"abf",
".",
"ID",
",",
"abf",
".",
"sweeps",
")",
")",
"plt",
".",
"gca",
"(",
")",
".",
"get_xaxis",
"(",
")",
".",
"set_visible",
"(",
"False",
")",
"plt",
".",
"subplot",
"(",
"212",
",",
"sharex",
"=",
"ax1",
")",
"plot",
".",
"figure_protocol",
"(",
")",
"plt",
".",
"title",
"(",
"\"\"",
")",
"else",
":",
"# long (probably a drug experiment)",
"plot",
".",
"figure_chronological",
"(",
")",
"else",
":",
"# protocol changes every sweep",
"plots",
"=",
"[",
"211",
",",
"212",
"]",
"# assume we want 2 images",
"if",
"abf",
".",
"units",
"==",
"'mV'",
":",
"# maybe it's something with APs?",
"ap",
"=",
"swhlab",
".",
"AP",
"(",
"abf",
")",
"# go ahead and do AP detection",
"ap",
".",
"detect",
"(",
")",
"# try to detect APs",
"if",
"len",
"(",
"ap",
".",
"APs",
")",
":",
"# if we found some",
"plots",
"=",
"[",
"221",
",",
"223",
",",
"222",
",",
"224",
"]",
"# get ready for 4 images",
"ax1",
"=",
"plt",
".",
"subplot",
"(",
"plots",
"[",
"0",
"]",
")",
"plot",
".",
"figure_sweeps",
"(",
")",
"plt",
".",
"title",
"(",
"\"{} ({} sweeps)\"",
".",
"format",
"(",
"abf",
".",
"ID",
",",
"abf",
".",
"sweeps",
")",
")",
"plt",
".",
"gca",
"(",
")",
".",
"get_xaxis",
"(",
")",
".",
"set_visible",
"(",
"False",
")",
"plt",
".",
"subplot",
"(",
"plots",
"[",
"1",
"]",
",",
"sharex",
"=",
"ax1",
")",
"plot",
".",
"figure_protocols",
"(",
")",
"plt",
".",
"title",
"(",
"\"protocol\"",
")",
"if",
"len",
"(",
"plots",
")",
">",
"2",
":",
"# assume we want to look at the first AP",
"ax2",
"=",
"plt",
".",
"subplot",
"(",
"plots",
"[",
"2",
"]",
")",
"plot",
".",
"rainbow",
"=",
"False",
"plot",
".",
"kwargs",
"[",
"\"color\"",
"]",
"=",
"'b'",
"plot",
".",
"figure_chronological",
"(",
")",
"plt",
".",
"gca",
"(",
")",
".",
"get_xaxis",
"(",
")",
".",
"set_visible",
"(",
"False",
")",
"plt",
".",
"title",
"(",
"\"first AP magnitude\"",
")",
"# velocity plot",
"plt",
".",
"subplot",
"(",
"plots",
"[",
"3",
"]",
",",
"sharex",
"=",
"ax2",
")",
"plot",
".",
"abf",
".",
"derivative",
"=",
"True",
"plot",
".",
"rainbow",
"=",
"False",
"plot",
".",
"traceColor",
"=",
"'r'",
"plot",
".",
"figure_chronological",
"(",
")",
"plt",
".",
"axis",
"(",
"[",
"ap",
".",
"APs",
"[",
"0",
"]",
"[",
"\"T\"",
"]",
"-",
".05",
",",
"ap",
".",
"APs",
"[",
"0",
"]",
"[",
"\"T\"",
"]",
"+",
".05",
",",
"None",
",",
"None",
"]",
")",
"plt",
".",
"title",
"(",
"\"first AP velocity\"",
")",
"if",
"saveAs",
":",
"print",
"(",
"\"saving\"",
",",
"os",
".",
"path",
".",
"abspath",
"(",
"saveAs",
")",
")",
"plt",
".",
"savefig",
"(",
"os",
".",
"path",
".",
"abspath",
"(",
"saveAs",
")",
",",
"dpi",
"=",
"dpi",
")",
"return",
"if",
"show",
":",
"plot",
".",
"show",
"(",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
frameAndSave
|
frame the current matplotlib plot with ABF info, and optionally save it.
Note that this is entirely independent of the ABFplot class object.
if saveImage is False, show it instead.
Datatype should be:
* plot
* experiment
|
swhlab/plotting/core.py
|
def frameAndSave(abf,tag="",dataType="plot",saveAsFname=False,closeWhenDone=True):
"""
frame the current matplotlib plot with ABF info, and optionally save it.
Note that this is entirely independent of the ABFplot class object.
if saveImage is False, show it instead.
Datatype should be:
* plot
* experiment
"""
print("closeWhenDone",closeWhenDone)
plt.tight_layout()
plt.subplots_adjust(top=.93,bottom =.07)
plt.annotate(tag,(.01,.99),xycoords='figure fraction',ha='left',va='top',family='monospace',size=10,alpha=.5)
msgBot="%s [%s]"%(abf.ID,abf.protocomment)
plt.annotate(msgBot,(.01,.01),xycoords='figure fraction',ha='left',va='bottom',family='monospace',size=10,alpha=.5)
fname=tag.lower().replace(" ",'_')+".jpg"
fname=dataType+"_"+fname
plt.tight_layout()
if IMAGE_SAVE:
abf.log.info("saving [%s]",fname)
try:
if saveAsFname:
saveAs=os.path.abspath(saveAsFname)
else:
saveAs=os.path.abspath(abf.outPre+fname)
if not os.path.exists(abf.outFolder):
os.mkdir(abf.outFolder)
plt.savefig(saveAs)
except Exception as E:
abf.log.error("saving [%s] failed! 'pip install pillow'?",fname)
print(E)
if IMAGE_SHOW==True:
if closeWhenDone==False:
print("NOT SHOWING (because closeWhenDone==True and showing would mess things up)")
else:
abf.log.info("showing [%s]",fname)
plt.show()
if closeWhenDone:
print("closing figure")
plt.close('all')
|
def frameAndSave(abf,tag="",dataType="plot",saveAsFname=False,closeWhenDone=True):
"""
frame the current matplotlib plot with ABF info, and optionally save it.
Note that this is entirely independent of the ABFplot class object.
if saveImage is False, show it instead.
Datatype should be:
* plot
* experiment
"""
print("closeWhenDone",closeWhenDone)
plt.tight_layout()
plt.subplots_adjust(top=.93,bottom =.07)
plt.annotate(tag,(.01,.99),xycoords='figure fraction',ha='left',va='top',family='monospace',size=10,alpha=.5)
msgBot="%s [%s]"%(abf.ID,abf.protocomment)
plt.annotate(msgBot,(.01,.01),xycoords='figure fraction',ha='left',va='bottom',family='monospace',size=10,alpha=.5)
fname=tag.lower().replace(" ",'_')+".jpg"
fname=dataType+"_"+fname
plt.tight_layout()
if IMAGE_SAVE:
abf.log.info("saving [%s]",fname)
try:
if saveAsFname:
saveAs=os.path.abspath(saveAsFname)
else:
saveAs=os.path.abspath(abf.outPre+fname)
if not os.path.exists(abf.outFolder):
os.mkdir(abf.outFolder)
plt.savefig(saveAs)
except Exception as E:
abf.log.error("saving [%s] failed! 'pip install pillow'?",fname)
print(E)
if IMAGE_SHOW==True:
if closeWhenDone==False:
print("NOT SHOWING (because closeWhenDone==True and showing would mess things up)")
else:
abf.log.info("showing [%s]",fname)
plt.show()
if closeWhenDone:
print("closing figure")
plt.close('all')
|
[
"frame",
"the",
"current",
"matplotlib",
"plot",
"with",
"ABF",
"info",
"and",
"optionally",
"save",
"it",
".",
"Note",
"that",
"this",
"is",
"entirely",
"independent",
"of",
"the",
"ABFplot",
"class",
"object",
".",
"if",
"saveImage",
"is",
"False",
"show",
"it",
"instead",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/plotting/core.py#L24-L64
|
[
"def",
"frameAndSave",
"(",
"abf",
",",
"tag",
"=",
"\"\"",
",",
"dataType",
"=",
"\"plot\"",
",",
"saveAsFname",
"=",
"False",
",",
"closeWhenDone",
"=",
"True",
")",
":",
"print",
"(",
"\"closeWhenDone\"",
",",
"closeWhenDone",
")",
"plt",
".",
"tight_layout",
"(",
")",
"plt",
".",
"subplots_adjust",
"(",
"top",
"=",
".93",
",",
"bottom",
"=",
".07",
")",
"plt",
".",
"annotate",
"(",
"tag",
",",
"(",
".01",
",",
".99",
")",
",",
"xycoords",
"=",
"'figure fraction'",
",",
"ha",
"=",
"'left'",
",",
"va",
"=",
"'top'",
",",
"family",
"=",
"'monospace'",
",",
"size",
"=",
"10",
",",
"alpha",
"=",
".5",
")",
"msgBot",
"=",
"\"%s [%s]\"",
"%",
"(",
"abf",
".",
"ID",
",",
"abf",
".",
"protocomment",
")",
"plt",
".",
"annotate",
"(",
"msgBot",
",",
"(",
".01",
",",
".01",
")",
",",
"xycoords",
"=",
"'figure fraction'",
",",
"ha",
"=",
"'left'",
",",
"va",
"=",
"'bottom'",
",",
"family",
"=",
"'monospace'",
",",
"size",
"=",
"10",
",",
"alpha",
"=",
".5",
")",
"fname",
"=",
"tag",
".",
"lower",
"(",
")",
".",
"replace",
"(",
"\" \"",
",",
"'_'",
")",
"+",
"\".jpg\"",
"fname",
"=",
"dataType",
"+",
"\"_\"",
"+",
"fname",
"plt",
".",
"tight_layout",
"(",
")",
"if",
"IMAGE_SAVE",
":",
"abf",
".",
"log",
".",
"info",
"(",
"\"saving [%s]\"",
",",
"fname",
")",
"try",
":",
"if",
"saveAsFname",
":",
"saveAs",
"=",
"os",
".",
"path",
".",
"abspath",
"(",
"saveAsFname",
")",
"else",
":",
"saveAs",
"=",
"os",
".",
"path",
".",
"abspath",
"(",
"abf",
".",
"outPre",
"+",
"fname",
")",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"abf",
".",
"outFolder",
")",
":",
"os",
".",
"mkdir",
"(",
"abf",
".",
"outFolder",
")",
"plt",
".",
"savefig",
"(",
"saveAs",
")",
"except",
"Exception",
"as",
"E",
":",
"abf",
".",
"log",
".",
"error",
"(",
"\"saving [%s] failed! 'pip install pillow'?\"",
",",
"fname",
")",
"print",
"(",
"E",
")",
"if",
"IMAGE_SHOW",
"==",
"True",
":",
"if",
"closeWhenDone",
"==",
"False",
":",
"print",
"(",
"\"NOT SHOWING (because closeWhenDone==True and showing would mess things up)\"",
")",
"else",
":",
"abf",
".",
"log",
".",
"info",
"(",
"\"showing [%s]\"",
",",
"fname",
")",
"plt",
".",
"show",
"(",
")",
"if",
"closeWhenDone",
":",
"print",
"(",
"\"closing figure\"",
")",
"plt",
".",
"close",
"(",
"'all'",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
ABFplot.figure
|
make sure a figure is ready.
|
swhlab/plotting/core.py
|
def figure(self,forceNew=False):
"""make sure a figure is ready."""
if plt._pylab_helpers.Gcf.get_num_fig_managers()>0 and forceNew is False:
self.log.debug("figure already seen, not creating one.")
return
if self.subplot:
self.log.debug("subplot mode enabled, not creating new figure")
else:
self.log.debug("creating new figure")
plt.figure(figsize=(self.figure_width,self.figure_height))
|
def figure(self,forceNew=False):
"""make sure a figure is ready."""
if plt._pylab_helpers.Gcf.get_num_fig_managers()>0 and forceNew is False:
self.log.debug("figure already seen, not creating one.")
return
if self.subplot:
self.log.debug("subplot mode enabled, not creating new figure")
else:
self.log.debug("creating new figure")
plt.figure(figsize=(self.figure_width,self.figure_height))
|
[
"make",
"sure",
"a",
"figure",
"is",
"ready",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/plotting/core.py#L99-L109
|
[
"def",
"figure",
"(",
"self",
",",
"forceNew",
"=",
"False",
")",
":",
"if",
"plt",
".",
"_pylab_helpers",
".",
"Gcf",
".",
"get_num_fig_managers",
"(",
")",
">",
"0",
"and",
"forceNew",
"is",
"False",
":",
"self",
".",
"log",
".",
"debug",
"(",
"\"figure already seen, not creating one.\"",
")",
"return",
"if",
"self",
".",
"subplot",
":",
"self",
".",
"log",
".",
"debug",
"(",
"\"subplot mode enabled, not creating new figure\"",
")",
"else",
":",
"self",
".",
"log",
".",
"debug",
"(",
"\"creating new figure\"",
")",
"plt",
".",
"figure",
"(",
"figsize",
"=",
"(",
"self",
".",
"figure_width",
",",
"self",
".",
"figure_height",
")",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
ABFplot.save
|
save the existing figure. does not close it.
|
swhlab/plotting/core.py
|
def save(self,callit="misc",closeToo=True,fullpath=False):
"""save the existing figure. does not close it."""
if fullpath is False:
fname=self.abf.outPre+"plot_"+callit+".jpg"
else:
fname=callit
if not os.path.exists(os.path.dirname(fname)):
os.mkdir(os.path.dirname(fname))
plt.savefig(fname)
self.log.info("saved [%s]",os.path.basename(fname))
if closeToo:
plt.close()
|
def save(self,callit="misc",closeToo=True,fullpath=False):
"""save the existing figure. does not close it."""
if fullpath is False:
fname=self.abf.outPre+"plot_"+callit+".jpg"
else:
fname=callit
if not os.path.exists(os.path.dirname(fname)):
os.mkdir(os.path.dirname(fname))
plt.savefig(fname)
self.log.info("saved [%s]",os.path.basename(fname))
if closeToo:
plt.close()
|
[
"save",
"the",
"existing",
"figure",
".",
"does",
"not",
"close",
"it",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/plotting/core.py#L125-L136
|
[
"def",
"save",
"(",
"self",
",",
"callit",
"=",
"\"misc\"",
",",
"closeToo",
"=",
"True",
",",
"fullpath",
"=",
"False",
")",
":",
"if",
"fullpath",
"is",
"False",
":",
"fname",
"=",
"self",
".",
"abf",
".",
"outPre",
"+",
"\"plot_\"",
"+",
"callit",
"+",
"\".jpg\"",
"else",
":",
"fname",
"=",
"callit",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"os",
".",
"path",
".",
"dirname",
"(",
"fname",
")",
")",
":",
"os",
".",
"mkdir",
"(",
"os",
".",
"path",
".",
"dirname",
"(",
"fname",
")",
")",
"plt",
".",
"savefig",
"(",
"fname",
")",
"self",
".",
"log",
".",
"info",
"(",
"\"saved [%s]\"",
",",
"os",
".",
"path",
".",
"basename",
"(",
"fname",
")",
")",
"if",
"closeToo",
":",
"plt",
".",
"close",
"(",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
ABFplot.comments
|
Add comment lines/text to an existing plot. Defaults to seconds.
Call after a plot has been made, and after margins have been set.
|
swhlab/plotting/core.py
|
def comments(self,minutes=False):
"""
Add comment lines/text to an existing plot. Defaults to seconds.
Call after a plot has been made, and after margins have been set.
"""
if self.comments==0:
return
self.log.debug("adding comments to plot")
for i,t in enumerate(self.abf.comment_times):
if minutes:
t/=60.0
plt.axvline(t,color='r',ls=':')
X1,X2,Y1,Y2=plt.axis()
Y2=Y2-abs(Y2-Y1)*.02
plt.text(t,Y2,self.abf.comment_tags[i],color='r',rotation='vertical',
ha='right',va='top',weight='bold',alpha=.5,size=8,)
|
def comments(self,minutes=False):
"""
Add comment lines/text to an existing plot. Defaults to seconds.
Call after a plot has been made, and after margins have been set.
"""
if self.comments==0:
return
self.log.debug("adding comments to plot")
for i,t in enumerate(self.abf.comment_times):
if minutes:
t/=60.0
plt.axvline(t,color='r',ls=':')
X1,X2,Y1,Y2=plt.axis()
Y2=Y2-abs(Y2-Y1)*.02
plt.text(t,Y2,self.abf.comment_tags[i],color='r',rotation='vertical',
ha='right',va='top',weight='bold',alpha=.5,size=8,)
|
[
"Add",
"comment",
"lines",
"/",
"text",
"to",
"an",
"existing",
"plot",
".",
"Defaults",
"to",
"seconds",
".",
"Call",
"after",
"a",
"plot",
"has",
"been",
"made",
"and",
"after",
"margins",
"have",
"been",
"set",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/plotting/core.py#L152-L167
|
[
"def",
"comments",
"(",
"self",
",",
"minutes",
"=",
"False",
")",
":",
"if",
"self",
".",
"comments",
"==",
"0",
":",
"return",
"self",
".",
"log",
".",
"debug",
"(",
"\"adding comments to plot\"",
")",
"for",
"i",
",",
"t",
"in",
"enumerate",
"(",
"self",
".",
"abf",
".",
"comment_times",
")",
":",
"if",
"minutes",
":",
"t",
"/=",
"60.0",
"plt",
".",
"axvline",
"(",
"t",
",",
"color",
"=",
"'r'",
",",
"ls",
"=",
"':'",
")",
"X1",
",",
"X2",
",",
"Y1",
",",
"Y2",
"=",
"plt",
".",
"axis",
"(",
")",
"Y2",
"=",
"Y2",
"-",
"abs",
"(",
"Y2",
"-",
"Y1",
")",
"*",
".02",
"plt",
".",
"text",
"(",
"t",
",",
"Y2",
",",
"self",
".",
"abf",
".",
"comment_tags",
"[",
"i",
"]",
",",
"color",
"=",
"'r'",
",",
"rotation",
"=",
"'vertical'",
",",
"ha",
"=",
"'right'",
",",
"va",
"=",
"'top'",
",",
"weight",
"=",
"'bold'",
",",
"alpha",
"=",
".5",
",",
"size",
"=",
"8",
",",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
ABFplot.figure_chronological
|
plot every sweep of an ABF file (with comments).
|
swhlab/plotting/core.py
|
def figure_chronological(self):
"""plot every sweep of an ABF file (with comments)."""
self.log.debug("creating chronological plot")
self.figure()
for sweep in range(self.abf.sweeps):
self.abf.setsweep(sweep)
self.setColorBySweep()
if self.abf.derivative:
plt.plot(self.abf.sweepX,self.abf.sweepD,**self.kwargs)
else:
plt.plot(self.abf.sweepX,self.abf.sweepY,**self.kwargs)
self.comments()
self.decorate()
|
def figure_chronological(self):
"""plot every sweep of an ABF file (with comments)."""
self.log.debug("creating chronological plot")
self.figure()
for sweep in range(self.abf.sweeps):
self.abf.setsweep(sweep)
self.setColorBySweep()
if self.abf.derivative:
plt.plot(self.abf.sweepX,self.abf.sweepD,**self.kwargs)
else:
plt.plot(self.abf.sweepX,self.abf.sweepY,**self.kwargs)
self.comments()
self.decorate()
|
[
"plot",
"every",
"sweep",
"of",
"an",
"ABF",
"file",
"(",
"with",
"comments",
")",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/plotting/core.py#L187-L199
|
[
"def",
"figure_chronological",
"(",
"self",
")",
":",
"self",
".",
"log",
".",
"debug",
"(",
"\"creating chronological plot\"",
")",
"self",
".",
"figure",
"(",
")",
"for",
"sweep",
"in",
"range",
"(",
"self",
".",
"abf",
".",
"sweeps",
")",
":",
"self",
".",
"abf",
".",
"setsweep",
"(",
"sweep",
")",
"self",
".",
"setColorBySweep",
"(",
")",
"if",
"self",
".",
"abf",
".",
"derivative",
":",
"plt",
".",
"plot",
"(",
"self",
".",
"abf",
".",
"sweepX",
",",
"self",
".",
"abf",
".",
"sweepD",
",",
"*",
"*",
"self",
".",
"kwargs",
")",
"else",
":",
"plt",
".",
"plot",
"(",
"self",
".",
"abf",
".",
"sweepX",
",",
"self",
".",
"abf",
".",
"sweepY",
",",
"*",
"*",
"self",
".",
"kwargs",
")",
"self",
".",
"comments",
"(",
")",
"self",
".",
"decorate",
"(",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
ABFplot.figure_sweeps
|
plot every sweep of an ABF file.
|
swhlab/plotting/core.py
|
def figure_sweeps(self, offsetX=0, offsetY=0):
"""plot every sweep of an ABF file."""
self.log.debug("creating overlayed sweeps plot")
self.figure()
for sweep in range(self.abf.sweeps):
self.abf.setsweep(sweep)
self.setColorBySweep()
plt.plot(self.abf.sweepX2+sweep*offsetX,
self.abf.sweepY+sweep*offsetY,
**self.kwargs)
if offsetX:
self.marginX=.05
self.decorate()
|
def figure_sweeps(self, offsetX=0, offsetY=0):
"""plot every sweep of an ABF file."""
self.log.debug("creating overlayed sweeps plot")
self.figure()
for sweep in range(self.abf.sweeps):
self.abf.setsweep(sweep)
self.setColorBySweep()
plt.plot(self.abf.sweepX2+sweep*offsetX,
self.abf.sweepY+sweep*offsetY,
**self.kwargs)
if offsetX:
self.marginX=.05
self.decorate()
|
[
"plot",
"every",
"sweep",
"of",
"an",
"ABF",
"file",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/plotting/core.py#L208-L220
|
[
"def",
"figure_sweeps",
"(",
"self",
",",
"offsetX",
"=",
"0",
",",
"offsetY",
"=",
"0",
")",
":",
"self",
".",
"log",
".",
"debug",
"(",
"\"creating overlayed sweeps plot\"",
")",
"self",
".",
"figure",
"(",
")",
"for",
"sweep",
"in",
"range",
"(",
"self",
".",
"abf",
".",
"sweeps",
")",
":",
"self",
".",
"abf",
".",
"setsweep",
"(",
"sweep",
")",
"self",
".",
"setColorBySweep",
"(",
")",
"plt",
".",
"plot",
"(",
"self",
".",
"abf",
".",
"sweepX2",
"+",
"sweep",
"*",
"offsetX",
",",
"self",
".",
"abf",
".",
"sweepY",
"+",
"sweep",
"*",
"offsetY",
",",
"*",
"*",
"self",
".",
"kwargs",
")",
"if",
"offsetX",
":",
"self",
".",
"marginX",
"=",
".05",
"self",
".",
"decorate",
"(",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
ABFplot.figure_protocol
|
plot the current sweep protocol.
|
swhlab/plotting/core.py
|
def figure_protocol(self):
"""plot the current sweep protocol."""
self.log.debug("creating overlayed protocols plot")
self.figure()
plt.plot(self.abf.protoX,self.abf.protoY,color='r')
self.marginX=0
self.decorate(protocol=True)
|
def figure_protocol(self):
"""plot the current sweep protocol."""
self.log.debug("creating overlayed protocols plot")
self.figure()
plt.plot(self.abf.protoX,self.abf.protoY,color='r')
self.marginX=0
self.decorate(protocol=True)
|
[
"plot",
"the",
"current",
"sweep",
"protocol",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/plotting/core.py#L222-L228
|
[
"def",
"figure_protocol",
"(",
"self",
")",
":",
"self",
".",
"log",
".",
"debug",
"(",
"\"creating overlayed protocols plot\"",
")",
"self",
".",
"figure",
"(",
")",
"plt",
".",
"plot",
"(",
"self",
".",
"abf",
".",
"protoX",
",",
"self",
".",
"abf",
".",
"protoY",
",",
"color",
"=",
"'r'",
")",
"self",
".",
"marginX",
"=",
"0",
"self",
".",
"decorate",
"(",
"protocol",
"=",
"True",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
ABFplot.figure_protocols
|
plot the protocol of all sweeps.
|
swhlab/plotting/core.py
|
def figure_protocols(self):
"""plot the protocol of all sweeps."""
self.log.debug("creating overlayed protocols plot")
self.figure()
for sweep in range(self.abf.sweeps):
self.abf.setsweep(sweep)
plt.plot(self.abf.protoX,self.abf.protoY,color='r')
self.marginX=0
self.decorate(protocol=True)
|
def figure_protocols(self):
"""plot the protocol of all sweeps."""
self.log.debug("creating overlayed protocols plot")
self.figure()
for sweep in range(self.abf.sweeps):
self.abf.setsweep(sweep)
plt.plot(self.abf.protoX,self.abf.protoY,color='r')
self.marginX=0
self.decorate(protocol=True)
|
[
"plot",
"the",
"protocol",
"of",
"all",
"sweeps",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/plotting/core.py#L230-L238
|
[
"def",
"figure_protocols",
"(",
"self",
")",
":",
"self",
".",
"log",
".",
"debug",
"(",
"\"creating overlayed protocols plot\"",
")",
"self",
".",
"figure",
"(",
")",
"for",
"sweep",
"in",
"range",
"(",
"self",
".",
"abf",
".",
"sweeps",
")",
":",
"self",
".",
"abf",
".",
"setsweep",
"(",
"sweep",
")",
"plt",
".",
"plot",
"(",
"self",
".",
"abf",
".",
"protoX",
",",
"self",
".",
"abf",
".",
"protoY",
",",
"color",
"=",
"'r'",
")",
"self",
".",
"marginX",
"=",
"0",
"self",
".",
"decorate",
"(",
"protocol",
"=",
"True",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
fread
|
Given an already-open (rb mode) file object, return a certain number of bytes at a specific location.
If a struct format is given, calculate the number of bytes required and return the object it represents.
|
doc/misc/reading abfs from scratch.py
|
def fread(f,byteLocation,structFormat=None,nBytes=1):
"""
Given an already-open (rb mode) file object, return a certain number of bytes at a specific location.
If a struct format is given, calculate the number of bytes required and return the object it represents.
"""
f.seek(byteLocation)
if structFormat:
val = struct.unpack(structFormat, f.read(struct.calcsize(structFormat)))
val = val[0] if len(val)==1 else list(val)
return val
else:
return f.read(nBytes)
|
def fread(f,byteLocation,structFormat=None,nBytes=1):
"""
Given an already-open (rb mode) file object, return a certain number of bytes at a specific location.
If a struct format is given, calculate the number of bytes required and return the object it represents.
"""
f.seek(byteLocation)
if structFormat:
val = struct.unpack(structFormat, f.read(struct.calcsize(structFormat)))
val = val[0] if len(val)==1 else list(val)
return val
else:
return f.read(nBytes)
|
[
"Given",
"an",
"already",
"-",
"open",
"(",
"rb",
"mode",
")",
"file",
"object",
"return",
"a",
"certain",
"number",
"of",
"bytes",
"at",
"a",
"specific",
"location",
".",
"If",
"a",
"struct",
"format",
"is",
"given",
"calculate",
"the",
"number",
"of",
"bytes",
"required",
"and",
"return",
"the",
"object",
"it",
"represents",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/misc/reading abfs from scratch.py#L79-L90
|
[
"def",
"fread",
"(",
"f",
",",
"byteLocation",
",",
"structFormat",
"=",
"None",
",",
"nBytes",
"=",
"1",
")",
":",
"f",
".",
"seek",
"(",
"byteLocation",
")",
"if",
"structFormat",
":",
"val",
"=",
"struct",
".",
"unpack",
"(",
"structFormat",
",",
"f",
".",
"read",
"(",
"struct",
".",
"calcsize",
"(",
"structFormat",
")",
")",
")",
"val",
"=",
"val",
"[",
"0",
"]",
"if",
"len",
"(",
"val",
")",
"==",
"1",
"else",
"list",
"(",
"val",
")",
"return",
"val",
"else",
":",
"return",
"f",
".",
"read",
"(",
"nBytes",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
abf_read_header
|
Practice pulling data straight out of an ABF's binary header. Support only ABF2 (ClampEx an ClampFit 10).
Use only native python libraries. Strive for simplicity and readability (to promote language portability).
This was made by Scott Harden after a line-by-line analysis of axonrawio.py from the neo io library.
Unlike NeoIO's format, I'm going to try to prevent nested dictionaries to keep things simple.
|
doc/misc/reading abfs from scratch.py
|
def abf_read_header(fname, saveHeader=True):
"""
Practice pulling data straight out of an ABF's binary header. Support only ABF2 (ClampEx an ClampFit 10).
Use only native python libraries. Strive for simplicity and readability (to promote language portability).
This was made by Scott Harden after a line-by-line analysis of axonrawio.py from the neo io library.
Unlike NeoIO's format, I'm going to try to prevent nested dictionaries to keep things simple.
"""
### THESE OBJETS WILL BE FULL WHEN THIS FUNCTION IS COMPLETE
header={} # information about the file format
sections={} # contains byte positions (and block sizes) for header information
strings=[] # a list of strings stored in the ABF header (protocol file, abf comment, and channel labels / units)
protocol = {} # info about the ABF recording
tags=[] # timed comments made during the abf as a list of lists [pos,comment,tagtype,voice]
adcs=[] # ADC info as a list of dicts
dacs=[] # DAC info as a list of dicts
digitalOutputs=[] # one 0b00000000 code per epoch
config={} # a concise collection of ABF info I think is useful. I intend only to return this object.
### READ THE FIRST PART OF THE FILE INTO MEMORY
# TODO: figure out the most memory-effecient way to do this
f=open(fname,'rb')
config["abf_filename"]=os.path.abspath(fname) # full path to the abf file on disk
config["abf_ID"]=os.path.basename(fname)[:-4] # abf filename without the ".abf"
### DECODE HEADER - this tells basic information about the file format
for key, byte_location, fmt in headerDescriptionV2:
header[key]=fread(f,byte_location,fmt)
header['fFileSignature']=header['fFileSignature'].decode()
### DECODE SECTIONS - sections are where (byte location) in this file different data is stored
for sectionNumber, sectionName in enumerate(sectionNames):
uBlockIndex, uBytes, llNumEntries = fread(f,76+sectionNumber*16,"IIl")
sections[sectionName] = [uBlockIndex,uBytes,llNumEntries]
config["abf_sweep_start_time"]=header['uFileStartTimeMS']/1000/1000
### DECODE STRINGS - figure out where (byte location) strings are in this file
# There are 20 strings. Protocol path, ABF comment, then alternating channel name and units.
byte_location = sections['StringsSection'][0]*BLOCKSIZE
string_size = sections['StringsSection'][1]
strings_data = fread(f,byte_location,structFormat=None,nBytes=string_size)
for key in [b'AXENGN', b'clampex', b'Clampex', b'CLAMPEX', b'axoscope']:
if key in strings_data:
for line in strings_data.split(key)[1].split(b'\x00')[1:-1]:
strings.append(line.decode())
config["abf_protocol_file"]=strings[0]
config["abf_comment"]=strings[1]
config["abf_channels"]=strings[2::2]
config["abf_units"]=strings[3::2]
break
### DECODE ADC INFO - a list of dictionaries, one per ADC employed
for ADCsection in range(sections['ADCSection'][2]):
thisADC={}
byte_location=sections['ADCSection'][0]*BLOCKSIZE+sections['ADCSection'][1]*ADCsection
for key, fmt in ADCInfoDescription:
thisADC[key]=fread(f,byte_location,fmt)
byte_location+=struct.calcsize(fmt)
adcs.append(thisADC)
### PROTOCOL - info about the nature of the recording
byte_location=sections['ProtocolSection'][0]*BLOCKSIZE
for key, fmt in protocolInfoDescription:
protocol[key]=fread(f,byte_location,fmt)
byte_location+=struct.calcsize(fmt)
protocol.pop('sUnused', None) # we don't need this
### TAGS (COMMMENTS) - those with a timestamp/comment (not those embedded in the protocol)
#TODO: not sure what the tagtime units actually are. Byte positions? Block number?
byte_location=sections['TagSection'][0]*BLOCKSIZE
for i in range(sections['TagSection'][2]):
thisTag=[]
for key, fmt in TagInfoDescription:
val=fread(f,byte_location,fmt)
if type(val) is bytes:
val=val.decode().strip()
thisTag.append(val)
byte_location+=struct.calcsize(fmt)
tags.append(thisTag)
### DAC SECTIONS
for dacNumber in range(sections['DACSection'][2]):
thisDAC={}
byte_location=sections['DACSection'][0]*BLOCKSIZE+sections['DACSection'][1]*dacNumber
for key, fmt in DACInfoDescription:
thisDAC[key]=fread(f,byte_location,fmt)
byte_location+=struct.calcsize(fmt)
thisDAC.pop('sUnused', None) # we don't need this
if thisDAC['nWaveformEnable']==0: continue # don't record unused DACs
dacs.append(thisDAC)
### EPOCHS PER DAC - this is what appear on the waveform tab
epochs=[]
for epochNumber in range(sections['EpochPerDACSection'][2]):
thisEpoch={}
byte_location=sections['EpochPerDACSection'][0]*BLOCKSIZE+sections['EpochPerDACSection'][1]*epochNumber
for key, fmt in EpochInfoPerDACDescription:
thisEpoch[key]=fread(f,byte_location,fmt)
byte_location+=struct.calcsize(fmt)
thisEpoch.pop('sUnused', None) # we don't need this
epochs.append(thisEpoch)
### DIGITAL OUTPUTS - this is where digital outputs are stored. Returns binary string (7-0)
# this does not exist in Neo IO. It was hacked-in by Scott Harden (github: swharden) to capture digital outputs.
# let's just add the digital output string to the epochs array we already have started.
byte_location=sections['EpochSection'][0]*BLOCKSIZE
for epochNumber in range(sections['EpochSection'][0]):
if epochNumber>=len(epochs):
break # don't bother looking up unused epochs
thisEpoch=epochs[epochNumber]
for key, fmt in EpochSectionDescription:
val=fread(f,byte_location,fmt)
if key=='nEpochDigitalOutput':
val=format(val, 'b').rjust(8,'0') # convert to a binary string (7->0)
thisEpoch[key]=val
byte_location+=struct.calcsize(fmt)
thisEpoch.pop('sUnused', None) # we don't need this
epochs[epochNumber]=thisEpoch
### WE ARE DONE READING THE FILE
f.close()
### EXTRA CONFIG - cherry-pick just what I find useful and arrange it in a simple dictionary
config["abfVersion"]=float("".join([str(x) for x in header['fFileVersionNumber']]))/100 # now a float
config['signalNames']=config['abf_channels'][:len(adcs)] # don't need more than the number of channels
config['signalUnits']=config['abf_units'][:len(adcs)] # don't need more than the number of channels
config['comments']=[x[:2] for x in tags]
config['nSweeps']=sections['SynchArraySection'][2]
# Determine the recording date from the header
YY = int(header['uFileStartDate'] / 10000)
MM = int((header['uFileStartDate'] - YY * 10000) / 100)
DD = int(header['uFileStartDate'] - YY * 10000 - MM * 100)
hh = int(header['uFileStartTimeMS'] / 1000. / 3600.)
mm = int((header['uFileStartTimeMS'] / 1000. - hh * 3600) / 60)
ss = header['uFileStartTimeMS'] / 1000. - hh * 3600 - mm * 60
ms = int((ss%1)*1e6)
ss = int(ss)
config['abf_datetime'] = datetime.datetime(YY, MM, DD, hh, mm, ss, ms)
|
def abf_read_header(fname, saveHeader=True):
"""
Practice pulling data straight out of an ABF's binary header. Support only ABF2 (ClampEx an ClampFit 10).
Use only native python libraries. Strive for simplicity and readability (to promote language portability).
This was made by Scott Harden after a line-by-line analysis of axonrawio.py from the neo io library.
Unlike NeoIO's format, I'm going to try to prevent nested dictionaries to keep things simple.
"""
### THESE OBJETS WILL BE FULL WHEN THIS FUNCTION IS COMPLETE
header={} # information about the file format
sections={} # contains byte positions (and block sizes) for header information
strings=[] # a list of strings stored in the ABF header (protocol file, abf comment, and channel labels / units)
protocol = {} # info about the ABF recording
tags=[] # timed comments made during the abf as a list of lists [pos,comment,tagtype,voice]
adcs=[] # ADC info as a list of dicts
dacs=[] # DAC info as a list of dicts
digitalOutputs=[] # one 0b00000000 code per epoch
config={} # a concise collection of ABF info I think is useful. I intend only to return this object.
### READ THE FIRST PART OF THE FILE INTO MEMORY
# TODO: figure out the most memory-effecient way to do this
f=open(fname,'rb')
config["abf_filename"]=os.path.abspath(fname) # full path to the abf file on disk
config["abf_ID"]=os.path.basename(fname)[:-4] # abf filename without the ".abf"
### DECODE HEADER - this tells basic information about the file format
for key, byte_location, fmt in headerDescriptionV2:
header[key]=fread(f,byte_location,fmt)
header['fFileSignature']=header['fFileSignature'].decode()
### DECODE SECTIONS - sections are where (byte location) in this file different data is stored
for sectionNumber, sectionName in enumerate(sectionNames):
uBlockIndex, uBytes, llNumEntries = fread(f,76+sectionNumber*16,"IIl")
sections[sectionName] = [uBlockIndex,uBytes,llNumEntries]
config["abf_sweep_start_time"]=header['uFileStartTimeMS']/1000/1000
### DECODE STRINGS - figure out where (byte location) strings are in this file
# There are 20 strings. Protocol path, ABF comment, then alternating channel name and units.
byte_location = sections['StringsSection'][0]*BLOCKSIZE
string_size = sections['StringsSection'][1]
strings_data = fread(f,byte_location,structFormat=None,nBytes=string_size)
for key in [b'AXENGN', b'clampex', b'Clampex', b'CLAMPEX', b'axoscope']:
if key in strings_data:
for line in strings_data.split(key)[1].split(b'\x00')[1:-1]:
strings.append(line.decode())
config["abf_protocol_file"]=strings[0]
config["abf_comment"]=strings[1]
config["abf_channels"]=strings[2::2]
config["abf_units"]=strings[3::2]
break
### DECODE ADC INFO - a list of dictionaries, one per ADC employed
for ADCsection in range(sections['ADCSection'][2]):
thisADC={}
byte_location=sections['ADCSection'][0]*BLOCKSIZE+sections['ADCSection'][1]*ADCsection
for key, fmt in ADCInfoDescription:
thisADC[key]=fread(f,byte_location,fmt)
byte_location+=struct.calcsize(fmt)
adcs.append(thisADC)
### PROTOCOL - info about the nature of the recording
byte_location=sections['ProtocolSection'][0]*BLOCKSIZE
for key, fmt in protocolInfoDescription:
protocol[key]=fread(f,byte_location,fmt)
byte_location+=struct.calcsize(fmt)
protocol.pop('sUnused', None) # we don't need this
### TAGS (COMMMENTS) - those with a timestamp/comment (not those embedded in the protocol)
#TODO: not sure what the tagtime units actually are. Byte positions? Block number?
byte_location=sections['TagSection'][0]*BLOCKSIZE
for i in range(sections['TagSection'][2]):
thisTag=[]
for key, fmt in TagInfoDescription:
val=fread(f,byte_location,fmt)
if type(val) is bytes:
val=val.decode().strip()
thisTag.append(val)
byte_location+=struct.calcsize(fmt)
tags.append(thisTag)
### DAC SECTIONS
for dacNumber in range(sections['DACSection'][2]):
thisDAC={}
byte_location=sections['DACSection'][0]*BLOCKSIZE+sections['DACSection'][1]*dacNumber
for key, fmt in DACInfoDescription:
thisDAC[key]=fread(f,byte_location,fmt)
byte_location+=struct.calcsize(fmt)
thisDAC.pop('sUnused', None) # we don't need this
if thisDAC['nWaveformEnable']==0: continue # don't record unused DACs
dacs.append(thisDAC)
### EPOCHS PER DAC - this is what appear on the waveform tab
epochs=[]
for epochNumber in range(sections['EpochPerDACSection'][2]):
thisEpoch={}
byte_location=sections['EpochPerDACSection'][0]*BLOCKSIZE+sections['EpochPerDACSection'][1]*epochNumber
for key, fmt in EpochInfoPerDACDescription:
thisEpoch[key]=fread(f,byte_location,fmt)
byte_location+=struct.calcsize(fmt)
thisEpoch.pop('sUnused', None) # we don't need this
epochs.append(thisEpoch)
### DIGITAL OUTPUTS - this is where digital outputs are stored. Returns binary string (7-0)
# this does not exist in Neo IO. It was hacked-in by Scott Harden (github: swharden) to capture digital outputs.
# let's just add the digital output string to the epochs array we already have started.
byte_location=sections['EpochSection'][0]*BLOCKSIZE
for epochNumber in range(sections['EpochSection'][0]):
if epochNumber>=len(epochs):
break # don't bother looking up unused epochs
thisEpoch=epochs[epochNumber]
for key, fmt in EpochSectionDescription:
val=fread(f,byte_location,fmt)
if key=='nEpochDigitalOutput':
val=format(val, 'b').rjust(8,'0') # convert to a binary string (7->0)
thisEpoch[key]=val
byte_location+=struct.calcsize(fmt)
thisEpoch.pop('sUnused', None) # we don't need this
epochs[epochNumber]=thisEpoch
### WE ARE DONE READING THE FILE
f.close()
### EXTRA CONFIG - cherry-pick just what I find useful and arrange it in a simple dictionary
config["abfVersion"]=float("".join([str(x) for x in header['fFileVersionNumber']]))/100 # now a float
config['signalNames']=config['abf_channels'][:len(adcs)] # don't need more than the number of channels
config['signalUnits']=config['abf_units'][:len(adcs)] # don't need more than the number of channels
config['comments']=[x[:2] for x in tags]
config['nSweeps']=sections['SynchArraySection'][2]
# Determine the recording date from the header
YY = int(header['uFileStartDate'] / 10000)
MM = int((header['uFileStartDate'] - YY * 10000) / 100)
DD = int(header['uFileStartDate'] - YY * 10000 - MM * 100)
hh = int(header['uFileStartTimeMS'] / 1000. / 3600.)
mm = int((header['uFileStartTimeMS'] / 1000. - hh * 3600) / 60)
ss = header['uFileStartTimeMS'] / 1000. - hh * 3600 - mm * 60
ms = int((ss%1)*1e6)
ss = int(ss)
config['abf_datetime'] = datetime.datetime(YY, MM, DD, hh, mm, ss, ms)
|
[
"Practice",
"pulling",
"data",
"straight",
"out",
"of",
"an",
"ABF",
"s",
"binary",
"header",
".",
"Support",
"only",
"ABF2",
"(",
"ClampEx",
"an",
"ClampFit",
"10",
")",
".",
"Use",
"only",
"native",
"python",
"libraries",
".",
"Strive",
"for",
"simplicity",
"and",
"readability",
"(",
"to",
"promote",
"language",
"portability",
")",
".",
"This",
"was",
"made",
"by",
"Scott",
"Harden",
"after",
"a",
"line",
"-",
"by",
"-",
"line",
"analysis",
"of",
"axonrawio",
".",
"py",
"from",
"the",
"neo",
"io",
"library",
".",
"Unlike",
"NeoIO",
"s",
"format",
"I",
"m",
"going",
"to",
"try",
"to",
"prevent",
"nested",
"dictionaries",
"to",
"keep",
"things",
"simple",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/misc/reading abfs from scratch.py#L92-L230
|
[
"def",
"abf_read_header",
"(",
"fname",
",",
"saveHeader",
"=",
"True",
")",
":",
"### THESE OBJETS WILL BE FULL WHEN THIS FUNCTION IS COMPLETE",
"header",
"=",
"{",
"}",
"# information about the file format",
"sections",
"=",
"{",
"}",
"# contains byte positions (and block sizes) for header information",
"strings",
"=",
"[",
"]",
"# a list of strings stored in the ABF header (protocol file, abf comment, and channel labels / units)",
"protocol",
"=",
"{",
"}",
"# info about the ABF recording",
"tags",
"=",
"[",
"]",
"# timed comments made during the abf as a list of lists [pos,comment,tagtype,voice]",
"adcs",
"=",
"[",
"]",
"# ADC info as a list of dicts",
"dacs",
"=",
"[",
"]",
"# DAC info as a list of dicts",
"digitalOutputs",
"=",
"[",
"]",
"# one 0b00000000 code per epoch",
"config",
"=",
"{",
"}",
"# a concise collection of ABF info I think is useful. I intend only to return this object.",
"### READ THE FIRST PART OF THE FILE INTO MEMORY",
"# TODO: figure out the most memory-effecient way to do this",
"f",
"=",
"open",
"(",
"fname",
",",
"'rb'",
")",
"config",
"[",
"\"abf_filename\"",
"]",
"=",
"os",
".",
"path",
".",
"abspath",
"(",
"fname",
")",
"# full path to the abf file on disk",
"config",
"[",
"\"abf_ID\"",
"]",
"=",
"os",
".",
"path",
".",
"basename",
"(",
"fname",
")",
"[",
":",
"-",
"4",
"]",
"# abf filename without the \".abf\"",
"### DECODE HEADER - this tells basic information about the file format",
"for",
"key",
",",
"byte_location",
",",
"fmt",
"in",
"headerDescriptionV2",
":",
"header",
"[",
"key",
"]",
"=",
"fread",
"(",
"f",
",",
"byte_location",
",",
"fmt",
")",
"header",
"[",
"'fFileSignature'",
"]",
"=",
"header",
"[",
"'fFileSignature'",
"]",
".",
"decode",
"(",
")",
"### DECODE SECTIONS - sections are where (byte location) in this file different data is stored",
"for",
"sectionNumber",
",",
"sectionName",
"in",
"enumerate",
"(",
"sectionNames",
")",
":",
"uBlockIndex",
",",
"uBytes",
",",
"llNumEntries",
"=",
"fread",
"(",
"f",
",",
"76",
"+",
"sectionNumber",
"*",
"16",
",",
"\"IIl\"",
")",
"sections",
"[",
"sectionName",
"]",
"=",
"[",
"uBlockIndex",
",",
"uBytes",
",",
"llNumEntries",
"]",
"config",
"[",
"\"abf_sweep_start_time\"",
"]",
"=",
"header",
"[",
"'uFileStartTimeMS'",
"]",
"/",
"1000",
"/",
"1000",
"### DECODE STRINGS - figure out where (byte location) strings are in this file",
"# There are 20 strings. Protocol path, ABF comment, then alternating channel name and units.",
"byte_location",
"=",
"sections",
"[",
"'StringsSection'",
"]",
"[",
"0",
"]",
"*",
"BLOCKSIZE",
"string_size",
"=",
"sections",
"[",
"'StringsSection'",
"]",
"[",
"1",
"]",
"strings_data",
"=",
"fread",
"(",
"f",
",",
"byte_location",
",",
"structFormat",
"=",
"None",
",",
"nBytes",
"=",
"string_size",
")",
"for",
"key",
"in",
"[",
"b'AXENGN'",
",",
"b'clampex'",
",",
"b'Clampex'",
",",
"b'CLAMPEX'",
",",
"b'axoscope'",
"]",
":",
"if",
"key",
"in",
"strings_data",
":",
"for",
"line",
"in",
"strings_data",
".",
"split",
"(",
"key",
")",
"[",
"1",
"]",
".",
"split",
"(",
"b'\\x00'",
")",
"[",
"1",
":",
"-",
"1",
"]",
":",
"strings",
".",
"append",
"(",
"line",
".",
"decode",
"(",
")",
")",
"config",
"[",
"\"abf_protocol_file\"",
"]",
"=",
"strings",
"[",
"0",
"]",
"config",
"[",
"\"abf_comment\"",
"]",
"=",
"strings",
"[",
"1",
"]",
"config",
"[",
"\"abf_channels\"",
"]",
"=",
"strings",
"[",
"2",
":",
":",
"2",
"]",
"config",
"[",
"\"abf_units\"",
"]",
"=",
"strings",
"[",
"3",
":",
":",
"2",
"]",
"break",
"### DECODE ADC INFO - a list of dictionaries, one per ADC employed",
"for",
"ADCsection",
"in",
"range",
"(",
"sections",
"[",
"'ADCSection'",
"]",
"[",
"2",
"]",
")",
":",
"thisADC",
"=",
"{",
"}",
"byte_location",
"=",
"sections",
"[",
"'ADCSection'",
"]",
"[",
"0",
"]",
"*",
"BLOCKSIZE",
"+",
"sections",
"[",
"'ADCSection'",
"]",
"[",
"1",
"]",
"*",
"ADCsection",
"for",
"key",
",",
"fmt",
"in",
"ADCInfoDescription",
":",
"thisADC",
"[",
"key",
"]",
"=",
"fread",
"(",
"f",
",",
"byte_location",
",",
"fmt",
")",
"byte_location",
"+=",
"struct",
".",
"calcsize",
"(",
"fmt",
")",
"adcs",
".",
"append",
"(",
"thisADC",
")",
"### PROTOCOL - info about the nature of the recording",
"byte_location",
"=",
"sections",
"[",
"'ProtocolSection'",
"]",
"[",
"0",
"]",
"*",
"BLOCKSIZE",
"for",
"key",
",",
"fmt",
"in",
"protocolInfoDescription",
":",
"protocol",
"[",
"key",
"]",
"=",
"fread",
"(",
"f",
",",
"byte_location",
",",
"fmt",
")",
"byte_location",
"+=",
"struct",
".",
"calcsize",
"(",
"fmt",
")",
"protocol",
".",
"pop",
"(",
"'sUnused'",
",",
"None",
")",
"# we don't need this",
"### TAGS (COMMMENTS) - those with a timestamp/comment (not those embedded in the protocol)",
"#TODO: not sure what the tagtime units actually are. Byte positions? Block number?",
"byte_location",
"=",
"sections",
"[",
"'TagSection'",
"]",
"[",
"0",
"]",
"*",
"BLOCKSIZE",
"for",
"i",
"in",
"range",
"(",
"sections",
"[",
"'TagSection'",
"]",
"[",
"2",
"]",
")",
":",
"thisTag",
"=",
"[",
"]",
"for",
"key",
",",
"fmt",
"in",
"TagInfoDescription",
":",
"val",
"=",
"fread",
"(",
"f",
",",
"byte_location",
",",
"fmt",
")",
"if",
"type",
"(",
"val",
")",
"is",
"bytes",
":",
"val",
"=",
"val",
".",
"decode",
"(",
")",
".",
"strip",
"(",
")",
"thisTag",
".",
"append",
"(",
"val",
")",
"byte_location",
"+=",
"struct",
".",
"calcsize",
"(",
"fmt",
")",
"tags",
".",
"append",
"(",
"thisTag",
")",
"### DAC SECTIONS ",
"for",
"dacNumber",
"in",
"range",
"(",
"sections",
"[",
"'DACSection'",
"]",
"[",
"2",
"]",
")",
":",
"thisDAC",
"=",
"{",
"}",
"byte_location",
"=",
"sections",
"[",
"'DACSection'",
"]",
"[",
"0",
"]",
"*",
"BLOCKSIZE",
"+",
"sections",
"[",
"'DACSection'",
"]",
"[",
"1",
"]",
"*",
"dacNumber",
"for",
"key",
",",
"fmt",
"in",
"DACInfoDescription",
":",
"thisDAC",
"[",
"key",
"]",
"=",
"fread",
"(",
"f",
",",
"byte_location",
",",
"fmt",
")",
"byte_location",
"+=",
"struct",
".",
"calcsize",
"(",
"fmt",
")",
"thisDAC",
".",
"pop",
"(",
"'sUnused'",
",",
"None",
")",
"# we don't need this",
"if",
"thisDAC",
"[",
"'nWaveformEnable'",
"]",
"==",
"0",
":",
"continue",
"# don't record unused DACs",
"dacs",
".",
"append",
"(",
"thisDAC",
")",
"### EPOCHS PER DAC - this is what appear on the waveform tab",
"epochs",
"=",
"[",
"]",
"for",
"epochNumber",
"in",
"range",
"(",
"sections",
"[",
"'EpochPerDACSection'",
"]",
"[",
"2",
"]",
")",
":",
"thisEpoch",
"=",
"{",
"}",
"byte_location",
"=",
"sections",
"[",
"'EpochPerDACSection'",
"]",
"[",
"0",
"]",
"*",
"BLOCKSIZE",
"+",
"sections",
"[",
"'EpochPerDACSection'",
"]",
"[",
"1",
"]",
"*",
"epochNumber",
"for",
"key",
",",
"fmt",
"in",
"EpochInfoPerDACDescription",
":",
"thisEpoch",
"[",
"key",
"]",
"=",
"fread",
"(",
"f",
",",
"byte_location",
",",
"fmt",
")",
"byte_location",
"+=",
"struct",
".",
"calcsize",
"(",
"fmt",
")",
"thisEpoch",
".",
"pop",
"(",
"'sUnused'",
",",
"None",
")",
"# we don't need this",
"epochs",
".",
"append",
"(",
"thisEpoch",
")",
"### DIGITAL OUTPUTS - this is where digital outputs are stored. Returns binary string (7-0)",
"# this does not exist in Neo IO. It was hacked-in by Scott Harden (github: swharden) to capture digital outputs.",
"# let's just add the digital output string to the epochs array we already have started.",
"byte_location",
"=",
"sections",
"[",
"'EpochSection'",
"]",
"[",
"0",
"]",
"*",
"BLOCKSIZE",
"for",
"epochNumber",
"in",
"range",
"(",
"sections",
"[",
"'EpochSection'",
"]",
"[",
"0",
"]",
")",
":",
"if",
"epochNumber",
">=",
"len",
"(",
"epochs",
")",
":",
"break",
"# don't bother looking up unused epochs",
"thisEpoch",
"=",
"epochs",
"[",
"epochNumber",
"]",
"for",
"key",
",",
"fmt",
"in",
"EpochSectionDescription",
":",
"val",
"=",
"fread",
"(",
"f",
",",
"byte_location",
",",
"fmt",
")",
"if",
"key",
"==",
"'nEpochDigitalOutput'",
":",
"val",
"=",
"format",
"(",
"val",
",",
"'b'",
")",
".",
"rjust",
"(",
"8",
",",
"'0'",
")",
"# convert to a binary string (7->0)",
"thisEpoch",
"[",
"key",
"]",
"=",
"val",
"byte_location",
"+=",
"struct",
".",
"calcsize",
"(",
"fmt",
")",
"thisEpoch",
".",
"pop",
"(",
"'sUnused'",
",",
"None",
")",
"# we don't need this",
"epochs",
"[",
"epochNumber",
"]",
"=",
"thisEpoch",
"### WE ARE DONE READING THE FILE",
"f",
".",
"close",
"(",
")",
"### EXTRA CONFIG - cherry-pick just what I find useful and arrange it in a simple dictionary",
"config",
"[",
"\"abfVersion\"",
"]",
"=",
"float",
"(",
"\"\"",
".",
"join",
"(",
"[",
"str",
"(",
"x",
")",
"for",
"x",
"in",
"header",
"[",
"'fFileVersionNumber'",
"]",
"]",
")",
")",
"/",
"100",
"# now a float",
"config",
"[",
"'signalNames'",
"]",
"=",
"config",
"[",
"'abf_channels'",
"]",
"[",
":",
"len",
"(",
"adcs",
")",
"]",
"# don't need more than the number of channels",
"config",
"[",
"'signalUnits'",
"]",
"=",
"config",
"[",
"'abf_units'",
"]",
"[",
":",
"len",
"(",
"adcs",
")",
"]",
"# don't need more than the number of channels",
"config",
"[",
"'comments'",
"]",
"=",
"[",
"x",
"[",
":",
"2",
"]",
"for",
"x",
"in",
"tags",
"]",
"config",
"[",
"'nSweeps'",
"]",
"=",
"sections",
"[",
"'SynchArraySection'",
"]",
"[",
"2",
"]",
"# Determine the recording date from the header ",
"YY",
"=",
"int",
"(",
"header",
"[",
"'uFileStartDate'",
"]",
"/",
"10000",
")",
"MM",
"=",
"int",
"(",
"(",
"header",
"[",
"'uFileStartDate'",
"]",
"-",
"YY",
"*",
"10000",
")",
"/",
"100",
")",
"DD",
"=",
"int",
"(",
"header",
"[",
"'uFileStartDate'",
"]",
"-",
"YY",
"*",
"10000",
"-",
"MM",
"*",
"100",
")",
"hh",
"=",
"int",
"(",
"header",
"[",
"'uFileStartTimeMS'",
"]",
"/",
"1000.",
"/",
"3600.",
")",
"mm",
"=",
"int",
"(",
"(",
"header",
"[",
"'uFileStartTimeMS'",
"]",
"/",
"1000.",
"-",
"hh",
"*",
"3600",
")",
"/",
"60",
")",
"ss",
"=",
"header",
"[",
"'uFileStartTimeMS'",
"]",
"/",
"1000.",
"-",
"hh",
"*",
"3600",
"-",
"mm",
"*",
"60",
"ms",
"=",
"int",
"(",
"(",
"ss",
"%",
"1",
")",
"*",
"1e6",
")",
"ss",
"=",
"int",
"(",
"ss",
")",
"config",
"[",
"'abf_datetime'",
"]",
"=",
"datetime",
".",
"datetime",
"(",
"YY",
",",
"MM",
",",
"DD",
",",
"hh",
",",
"mm",
",",
"ss",
",",
"ms",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
frames
|
create and save a two column frames HTML file.
|
swhlab/indexing/style.py
|
def frames(fname=None,menuWidth=200,launch=False):
"""create and save a two column frames HTML file."""
html="""
<frameset cols="%dpx,*%%">
<frame name="menu" src="index_menu.html">
<frame name="content" src="index_splash.html">
</frameset>"""%(menuWidth)
with open(fname,'w') as f:
f.write(html)
if launch:
webbrowser.open(fname)
|
def frames(fname=None,menuWidth=200,launch=False):
"""create and save a two column frames HTML file."""
html="""
<frameset cols="%dpx,*%%">
<frame name="menu" src="index_menu.html">
<frame name="content" src="index_splash.html">
</frameset>"""%(menuWidth)
with open(fname,'w') as f:
f.write(html)
if launch:
webbrowser.open(fname)
|
[
"create",
"and",
"save",
"a",
"two",
"column",
"frames",
"HTML",
"file",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/indexing/style.py#L68-L78
|
[
"def",
"frames",
"(",
"fname",
"=",
"None",
",",
"menuWidth",
"=",
"200",
",",
"launch",
"=",
"False",
")",
":",
"html",
"=",
"\"\"\"\n <frameset cols=\"%dpx,*%%\">\n <frame name=\"menu\" src=\"index_menu.html\">\n <frame name=\"content\" src=\"index_splash.html\">\n </frameset>\"\"\"",
"%",
"(",
"menuWidth",
")",
"with",
"open",
"(",
"fname",
",",
"'w'",
")",
"as",
"f",
":",
"f",
".",
"write",
"(",
"html",
")",
"if",
"launch",
":",
"webbrowser",
".",
"open",
"(",
"fname",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
save
|
wrap HTML in a top and bottom (with css) and save to disk.
|
swhlab/indexing/style.py
|
def save(html,fname=None,launch=False):
"""wrap HTML in a top and bottom (with css) and save to disk."""
html=html_top+html+html_bot
html=html.replace("~GENAT~",swhlab.common.datetimeToString())
if fname is None:
fname = tempfile.gettempdir()+"/temp.html"
launch=True
fname=os.path.abspath(fname)
with open(fname,'w') as f:
f.write(html)
global stylesheetSaved
stylesheetPath=os.path.join(os.path.dirname(fname),"style.css")
if not os.path.exists(stylesheetPath) or stylesheetSaved is False:
with open(stylesheetPath,'w') as f:
f.write(stylesheet)
stylesheetSaved=True
if launch:
webbrowser.open(fname)
|
def save(html,fname=None,launch=False):
"""wrap HTML in a top and bottom (with css) and save to disk."""
html=html_top+html+html_bot
html=html.replace("~GENAT~",swhlab.common.datetimeToString())
if fname is None:
fname = tempfile.gettempdir()+"/temp.html"
launch=True
fname=os.path.abspath(fname)
with open(fname,'w') as f:
f.write(html)
global stylesheetSaved
stylesheetPath=os.path.join(os.path.dirname(fname),"style.css")
if not os.path.exists(stylesheetPath) or stylesheetSaved is False:
with open(stylesheetPath,'w') as f:
f.write(stylesheet)
stylesheetSaved=True
if launch:
webbrowser.open(fname)
|
[
"wrap",
"HTML",
"in",
"a",
"top",
"and",
"bottom",
"(",
"with",
"css",
")",
"and",
"save",
"to",
"disk",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/indexing/style.py#L80-L98
|
[
"def",
"save",
"(",
"html",
",",
"fname",
"=",
"None",
",",
"launch",
"=",
"False",
")",
":",
"html",
"=",
"html_top",
"+",
"html",
"+",
"html_bot",
"html",
"=",
"html",
".",
"replace",
"(",
"\"~GENAT~\"",
",",
"swhlab",
".",
"common",
".",
"datetimeToString",
"(",
")",
")",
"if",
"fname",
"is",
"None",
":",
"fname",
"=",
"tempfile",
".",
"gettempdir",
"(",
")",
"+",
"\"/temp.html\"",
"launch",
"=",
"True",
"fname",
"=",
"os",
".",
"path",
".",
"abspath",
"(",
"fname",
")",
"with",
"open",
"(",
"fname",
",",
"'w'",
")",
"as",
"f",
":",
"f",
".",
"write",
"(",
"html",
")",
"global",
"stylesheetSaved",
"stylesheetPath",
"=",
"os",
".",
"path",
".",
"join",
"(",
"os",
".",
"path",
".",
"dirname",
"(",
"fname",
")",
",",
"\"style.css\"",
")",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"stylesheetPath",
")",
"or",
"stylesheetSaved",
"is",
"False",
":",
"with",
"open",
"(",
"stylesheetPath",
",",
"'w'",
")",
"as",
"f",
":",
"f",
".",
"write",
"(",
"stylesheet",
")",
"stylesheetSaved",
"=",
"True",
"if",
"launch",
":",
"webbrowser",
".",
"open",
"(",
"fname",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
clampfit_rename
|
Given ABFs and TIFs formatted long style, rename each of them to prefix their number with a different number.
Example: 2017_10_11_0011.abf
Becomes: 2017_10_11_?011.abf
where ? can be any character.
|
swhlab/tools/rename.py
|
def clampfit_rename(path,char):
"""
Given ABFs and TIFs formatted long style, rename each of them to prefix their number with a different number.
Example: 2017_10_11_0011.abf
Becomes: 2017_10_11_?011.abf
where ? can be any character.
"""
assert len(char)==1 and type(char)==str, "replacement character must be a single character"
assert os.path.exists(path), "path doesn't exist"
files = sorted(os.listdir(path))
files = [x for x in files if len(x)>18 and x[4]+x[7]+x[10]=='___']
for fname in files:
fname2 = list(fname)
fname2[11]=char
fname2="".join(fname2)
if fname==fname2:
print(fname, "==", fname2)
else:
print(fname, "->", fname2)
# fname=os.path.join(path,fname)
# fname2=os.path.join(path,fname2)
# if not os.path.exists(fname2):
# os.rename(fname,fname2)
return
|
def clampfit_rename(path,char):
"""
Given ABFs and TIFs formatted long style, rename each of them to prefix their number with a different number.
Example: 2017_10_11_0011.abf
Becomes: 2017_10_11_?011.abf
where ? can be any character.
"""
assert len(char)==1 and type(char)==str, "replacement character must be a single character"
assert os.path.exists(path), "path doesn't exist"
files = sorted(os.listdir(path))
files = [x for x in files if len(x)>18 and x[4]+x[7]+x[10]=='___']
for fname in files:
fname2 = list(fname)
fname2[11]=char
fname2="".join(fname2)
if fname==fname2:
print(fname, "==", fname2)
else:
print(fname, "->", fname2)
# fname=os.path.join(path,fname)
# fname2=os.path.join(path,fname2)
# if not os.path.exists(fname2):
# os.rename(fname,fname2)
return
|
[
"Given",
"ABFs",
"and",
"TIFs",
"formatted",
"long",
"style",
"rename",
"each",
"of",
"them",
"to",
"prefix",
"their",
"number",
"with",
"a",
"different",
"number",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/tools/rename.py#L3-L28
|
[
"def",
"clampfit_rename",
"(",
"path",
",",
"char",
")",
":",
"assert",
"len",
"(",
"char",
")",
"==",
"1",
"and",
"type",
"(",
"char",
")",
"==",
"str",
",",
"\"replacement character must be a single character\"",
"assert",
"os",
".",
"path",
".",
"exists",
"(",
"path",
")",
",",
"\"path doesn't exist\"",
"files",
"=",
"sorted",
"(",
"os",
".",
"listdir",
"(",
"path",
")",
")",
"files",
"=",
"[",
"x",
"for",
"x",
"in",
"files",
"if",
"len",
"(",
"x",
")",
">",
"18",
"and",
"x",
"[",
"4",
"]",
"+",
"x",
"[",
"7",
"]",
"+",
"x",
"[",
"10",
"]",
"==",
"'___'",
"]",
"for",
"fname",
"in",
"files",
":",
"fname2",
"=",
"list",
"(",
"fname",
")",
"fname2",
"[",
"11",
"]",
"=",
"char",
"fname2",
"=",
"\"\"",
".",
"join",
"(",
"fname2",
")",
"if",
"fname",
"==",
"fname2",
":",
"print",
"(",
"fname",
",",
"\"==\"",
",",
"fname2",
")",
"else",
":",
"print",
"(",
"fname",
",",
"\"->\"",
",",
"fname2",
")",
"# fname=os.path.join(path,fname)",
"# fname2=os.path.join(path,fname2)",
"# if not os.path.exists(fname2):",
"# os.rename(fname,fname2)",
"return"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
kernel_gaussian
|
return a 1d gassuan array of a given size and sigma.
If sigma isn't given, it will be 1/10 of the size, which is usually good.
|
doc/uses/EPSCs-and-IPSCs/smooth histogram method/01.py
|
def kernel_gaussian(size=100, sigma=None, forwardOnly=False):
"""
return a 1d gassuan array of a given size and sigma.
If sigma isn't given, it will be 1/10 of the size, which is usually good.
"""
if sigma is None:sigma=size/10
points=np.exp(-np.power(np.arange(size)-size/2,2)/(2*np.power(sigma,2)))
if forwardOnly:
points[:int(len(points)/2)]=0
return points/sum(points)
|
def kernel_gaussian(size=100, sigma=None, forwardOnly=False):
"""
return a 1d gassuan array of a given size and sigma.
If sigma isn't given, it will be 1/10 of the size, which is usually good.
"""
if sigma is None:sigma=size/10
points=np.exp(-np.power(np.arange(size)-size/2,2)/(2*np.power(sigma,2)))
if forwardOnly:
points[:int(len(points)/2)]=0
return points/sum(points)
|
[
"return",
"a",
"1d",
"gassuan",
"array",
"of",
"a",
"given",
"size",
"and",
"sigma",
".",
"If",
"sigma",
"isn",
"t",
"given",
"it",
"will",
"be",
"1",
"/",
"10",
"of",
"the",
"size",
"which",
"is",
"usually",
"good",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/uses/EPSCs-and-IPSCs/smooth histogram method/01.py#L19-L28
|
[
"def",
"kernel_gaussian",
"(",
"size",
"=",
"100",
",",
"sigma",
"=",
"None",
",",
"forwardOnly",
"=",
"False",
")",
":",
"if",
"sigma",
"is",
"None",
":",
"sigma",
"=",
"size",
"/",
"10",
"points",
"=",
"np",
".",
"exp",
"(",
"-",
"np",
".",
"power",
"(",
"np",
".",
"arange",
"(",
"size",
")",
"-",
"size",
"/",
"2",
",",
"2",
")",
"/",
"(",
"2",
"*",
"np",
".",
"power",
"(",
"sigma",
",",
"2",
")",
")",
")",
"if",
"forwardOnly",
":",
"points",
"[",
":",
"int",
"(",
"len",
"(",
"points",
")",
"/",
"2",
")",
"]",
"=",
"0",
"return",
"points",
"/",
"sum",
"(",
"points",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
analyzeSweep
|
m1 and m2, if given, are in seconds.
returns [# EPSCs, # IPSCs]
|
doc/uses/EPSCs-and-IPSCs/smooth histogram method/01.py
|
def analyzeSweep(abf,sweep,m1=None,m2=None,plotToo=False):
"""
m1 and m2, if given, are in seconds.
returns [# EPSCs, # IPSCs]
"""
abf.setsweep(sweep)
if m1 is None: m1=0
else: m1=m1*abf.pointsPerSec
if m2 is None: m2=-1
else: m2=m2*abf.pointsPerSec
# obtain X and Y
Yorig=abf.sweepY[int(m1):int(m2)]
X=np.arange(len(Yorig))/abf.pointsPerSec
# start by lowpass filtering (1 direction)
# Klpf=kernel_gaussian(size=abf.pointsPerMs*10,forwardOnly=True)
# Ylpf=np.convolve(Yorig,Klpf,mode='same')
# Y=Ylpf # commit
Kmb=kernel_gaussian(size=abf.pointsPerMs*10,forwardOnly=True)
Ymb=np.convolve(Yorig,Kmb,mode='same')
Y=Yorig-Ymb # commit
#Y1=np.copy(Y)
#Y[np.where(Y>0)[0]]=np.power(Y,2)
#Y[np.where(Y<0)[0]]=-np.power(Y,2)
# event detection
thresh=5 # threshold for an event
hitPos=np.where(Y>thresh)[0] # area above the threshold
hitNeg=np.where(Y<-thresh)[0] # area below the threshold
hitPos=np.concatenate((hitPos,[len(Y)-1])) # helps with the diff() coming up
hitNeg=np.concatenate((hitNeg,[len(Y)-1])) # helps with the diff() coming up
hitsPos=hitPos[np.where(np.abs(np.diff(hitPos))>10)[0]] # time point of EPSC
hitsNeg=hitNeg[np.where(np.abs(np.diff(hitNeg))>10)[0]] # time point of IPSC
hitsNeg=hitsNeg[1:] # often the first one is in error
#print(hitsNeg[0])
if plotToo:
plt.figure(figsize=(10,5))
ax1=plt.subplot(211)
plt.title("sweep %d: detected %d IPSCs (red) and %d EPSCs (blue)"%(sweep,len(hitsPos),len(hitsNeg)))
plt.ylabel("delta pA")
plt.grid()
plt.plot(X,Yorig,color='k',alpha=.5)
for hit in hitsPos:
plt.plot(X[hit],Yorig[hit]+20,'r.',ms=20,alpha=.5)
for hit in hitsNeg:
plt.plot(X[hit],Yorig[hit]-20,'b.',ms=20,alpha=.5)
plt.margins(0,.1)
plt.subplot(212,sharex=ax1)
plt.title("moving gaussian baseline subtraction used for threshold detection")
plt.ylabel("delta pA")
plt.grid()
plt.axhline(thresh,color='r',ls='--',alpha=.5,lw=3)
plt.axhline(-thresh,color='r',ls='--',alpha=.5,lw=3)
plt.plot(X,Y,color='b',alpha=.5)
plt.axis([X[0],X[-1],-thresh*1.5,thresh*1.5])
plt.tight_layout()
if type(plotToo) is str and os.path.isdir(plotToo):
print('saving %s/%05d.jpg'%(plotToo,sweep))
plt.savefig(plotToo+"/%05d.jpg"%sweep)
else:
plt.show()
plt.close('all')
return [len(hitsPos),len(hitsNeg)]
|
def analyzeSweep(abf,sweep,m1=None,m2=None,plotToo=False):
"""
m1 and m2, if given, are in seconds.
returns [# EPSCs, # IPSCs]
"""
abf.setsweep(sweep)
if m1 is None: m1=0
else: m1=m1*abf.pointsPerSec
if m2 is None: m2=-1
else: m2=m2*abf.pointsPerSec
# obtain X and Y
Yorig=abf.sweepY[int(m1):int(m2)]
X=np.arange(len(Yorig))/abf.pointsPerSec
# start by lowpass filtering (1 direction)
# Klpf=kernel_gaussian(size=abf.pointsPerMs*10,forwardOnly=True)
# Ylpf=np.convolve(Yorig,Klpf,mode='same')
# Y=Ylpf # commit
Kmb=kernel_gaussian(size=abf.pointsPerMs*10,forwardOnly=True)
Ymb=np.convolve(Yorig,Kmb,mode='same')
Y=Yorig-Ymb # commit
#Y1=np.copy(Y)
#Y[np.where(Y>0)[0]]=np.power(Y,2)
#Y[np.where(Y<0)[0]]=-np.power(Y,2)
# event detection
thresh=5 # threshold for an event
hitPos=np.where(Y>thresh)[0] # area above the threshold
hitNeg=np.where(Y<-thresh)[0] # area below the threshold
hitPos=np.concatenate((hitPos,[len(Y)-1])) # helps with the diff() coming up
hitNeg=np.concatenate((hitNeg,[len(Y)-1])) # helps with the diff() coming up
hitsPos=hitPos[np.where(np.abs(np.diff(hitPos))>10)[0]] # time point of EPSC
hitsNeg=hitNeg[np.where(np.abs(np.diff(hitNeg))>10)[0]] # time point of IPSC
hitsNeg=hitsNeg[1:] # often the first one is in error
#print(hitsNeg[0])
if plotToo:
plt.figure(figsize=(10,5))
ax1=plt.subplot(211)
plt.title("sweep %d: detected %d IPSCs (red) and %d EPSCs (blue)"%(sweep,len(hitsPos),len(hitsNeg)))
plt.ylabel("delta pA")
plt.grid()
plt.plot(X,Yorig,color='k',alpha=.5)
for hit in hitsPos:
plt.plot(X[hit],Yorig[hit]+20,'r.',ms=20,alpha=.5)
for hit in hitsNeg:
plt.plot(X[hit],Yorig[hit]-20,'b.',ms=20,alpha=.5)
plt.margins(0,.1)
plt.subplot(212,sharex=ax1)
plt.title("moving gaussian baseline subtraction used for threshold detection")
plt.ylabel("delta pA")
plt.grid()
plt.axhline(thresh,color='r',ls='--',alpha=.5,lw=3)
plt.axhline(-thresh,color='r',ls='--',alpha=.5,lw=3)
plt.plot(X,Y,color='b',alpha=.5)
plt.axis([X[0],X[-1],-thresh*1.5,thresh*1.5])
plt.tight_layout()
if type(plotToo) is str and os.path.isdir(plotToo):
print('saving %s/%05d.jpg'%(plotToo,sweep))
plt.savefig(plotToo+"/%05d.jpg"%sweep)
else:
plt.show()
plt.close('all')
return [len(hitsPos),len(hitsNeg)]
|
[
"m1",
"and",
"m2",
"if",
"given",
"are",
"in",
"seconds",
".",
"returns",
"[",
"#",
"EPSCs",
"#",
"IPSCs",
"]"
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/uses/EPSCs-and-IPSCs/smooth histogram method/01.py#L105-L175
|
[
"def",
"analyzeSweep",
"(",
"abf",
",",
"sweep",
",",
"m1",
"=",
"None",
",",
"m2",
"=",
"None",
",",
"plotToo",
"=",
"False",
")",
":",
"abf",
".",
"setsweep",
"(",
"sweep",
")",
"if",
"m1",
"is",
"None",
":",
"m1",
"=",
"0",
"else",
":",
"m1",
"=",
"m1",
"*",
"abf",
".",
"pointsPerSec",
"if",
"m2",
"is",
"None",
":",
"m2",
"=",
"-",
"1",
"else",
":",
"m2",
"=",
"m2",
"*",
"abf",
".",
"pointsPerSec",
"# obtain X and Y",
"Yorig",
"=",
"abf",
".",
"sweepY",
"[",
"int",
"(",
"m1",
")",
":",
"int",
"(",
"m2",
")",
"]",
"X",
"=",
"np",
".",
"arange",
"(",
"len",
"(",
"Yorig",
")",
")",
"/",
"abf",
".",
"pointsPerSec",
"# start by lowpass filtering (1 direction)",
"# Klpf=kernel_gaussian(size=abf.pointsPerMs*10,forwardOnly=True)",
"# Ylpf=np.convolve(Yorig,Klpf,mode='same')",
"# Y=Ylpf # commit",
"Kmb",
"=",
"kernel_gaussian",
"(",
"size",
"=",
"abf",
".",
"pointsPerMs",
"*",
"10",
",",
"forwardOnly",
"=",
"True",
")",
"Ymb",
"=",
"np",
".",
"convolve",
"(",
"Yorig",
",",
"Kmb",
",",
"mode",
"=",
"'same'",
")",
"Y",
"=",
"Yorig",
"-",
"Ymb",
"# commit",
"#Y1=np.copy(Y)",
"#Y[np.where(Y>0)[0]]=np.power(Y,2)",
"#Y[np.where(Y<0)[0]]=-np.power(Y,2)",
"# event detection",
"thresh",
"=",
"5",
"# threshold for an event",
"hitPos",
"=",
"np",
".",
"where",
"(",
"Y",
">",
"thresh",
")",
"[",
"0",
"]",
"# area above the threshold",
"hitNeg",
"=",
"np",
".",
"where",
"(",
"Y",
"<",
"-",
"thresh",
")",
"[",
"0",
"]",
"# area below the threshold",
"hitPos",
"=",
"np",
".",
"concatenate",
"(",
"(",
"hitPos",
",",
"[",
"len",
"(",
"Y",
")",
"-",
"1",
"]",
")",
")",
"# helps with the diff() coming up",
"hitNeg",
"=",
"np",
".",
"concatenate",
"(",
"(",
"hitNeg",
",",
"[",
"len",
"(",
"Y",
")",
"-",
"1",
"]",
")",
")",
"# helps with the diff() coming up",
"hitsPos",
"=",
"hitPos",
"[",
"np",
".",
"where",
"(",
"np",
".",
"abs",
"(",
"np",
".",
"diff",
"(",
"hitPos",
")",
")",
">",
"10",
")",
"[",
"0",
"]",
"]",
"# time point of EPSC",
"hitsNeg",
"=",
"hitNeg",
"[",
"np",
".",
"where",
"(",
"np",
".",
"abs",
"(",
"np",
".",
"diff",
"(",
"hitNeg",
")",
")",
">",
"10",
")",
"[",
"0",
"]",
"]",
"# time point of IPSC",
"hitsNeg",
"=",
"hitsNeg",
"[",
"1",
":",
"]",
"# often the first one is in error",
"#print(hitsNeg[0])",
"if",
"plotToo",
":",
"plt",
".",
"figure",
"(",
"figsize",
"=",
"(",
"10",
",",
"5",
")",
")",
"ax1",
"=",
"plt",
".",
"subplot",
"(",
"211",
")",
"plt",
".",
"title",
"(",
"\"sweep %d: detected %d IPSCs (red) and %d EPSCs (blue)\"",
"%",
"(",
"sweep",
",",
"len",
"(",
"hitsPos",
")",
",",
"len",
"(",
"hitsNeg",
")",
")",
")",
"plt",
".",
"ylabel",
"(",
"\"delta pA\"",
")",
"plt",
".",
"grid",
"(",
")",
"plt",
".",
"plot",
"(",
"X",
",",
"Yorig",
",",
"color",
"=",
"'k'",
",",
"alpha",
"=",
".5",
")",
"for",
"hit",
"in",
"hitsPos",
":",
"plt",
".",
"plot",
"(",
"X",
"[",
"hit",
"]",
",",
"Yorig",
"[",
"hit",
"]",
"+",
"20",
",",
"'r.'",
",",
"ms",
"=",
"20",
",",
"alpha",
"=",
".5",
")",
"for",
"hit",
"in",
"hitsNeg",
":",
"plt",
".",
"plot",
"(",
"X",
"[",
"hit",
"]",
",",
"Yorig",
"[",
"hit",
"]",
"-",
"20",
",",
"'b.'",
",",
"ms",
"=",
"20",
",",
"alpha",
"=",
".5",
")",
"plt",
".",
"margins",
"(",
"0",
",",
".1",
")",
"plt",
".",
"subplot",
"(",
"212",
",",
"sharex",
"=",
"ax1",
")",
"plt",
".",
"title",
"(",
"\"moving gaussian baseline subtraction used for threshold detection\"",
")",
"plt",
".",
"ylabel",
"(",
"\"delta pA\"",
")",
"plt",
".",
"grid",
"(",
")",
"plt",
".",
"axhline",
"(",
"thresh",
",",
"color",
"=",
"'r'",
",",
"ls",
"=",
"'--'",
",",
"alpha",
"=",
".5",
",",
"lw",
"=",
"3",
")",
"plt",
".",
"axhline",
"(",
"-",
"thresh",
",",
"color",
"=",
"'r'",
",",
"ls",
"=",
"'--'",
",",
"alpha",
"=",
".5",
",",
"lw",
"=",
"3",
")",
"plt",
".",
"plot",
"(",
"X",
",",
"Y",
",",
"color",
"=",
"'b'",
",",
"alpha",
"=",
".5",
")",
"plt",
".",
"axis",
"(",
"[",
"X",
"[",
"0",
"]",
",",
"X",
"[",
"-",
"1",
"]",
",",
"-",
"thresh",
"*",
"1.5",
",",
"thresh",
"*",
"1.5",
"]",
")",
"plt",
".",
"tight_layout",
"(",
")",
"if",
"type",
"(",
"plotToo",
")",
"is",
"str",
"and",
"os",
".",
"path",
".",
"isdir",
"(",
"plotToo",
")",
":",
"print",
"(",
"'saving %s/%05d.jpg'",
"%",
"(",
"plotToo",
",",
"sweep",
")",
")",
"plt",
".",
"savefig",
"(",
"plotToo",
"+",
"\"/%05d.jpg\"",
"%",
"sweep",
")",
"else",
":",
"plt",
".",
"show",
"(",
")",
"plt",
".",
"close",
"(",
"'all'",
")",
"return",
"[",
"len",
"(",
"hitsPos",
")",
",",
"len",
"(",
"hitsNeg",
")",
"]"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
filesByExtension
|
given a list of files, return a dict organized by extension.
|
swhlab/indexing/index_OLD.py
|
def filesByExtension(fnames):
"""given a list of files, return a dict organized by extension."""
byExt={"abf":[],"jpg":[],"tif":[]} # prime it with empties
for fname in fnames:
ext = os.path.splitext(fname)[1].replace(".",'').lower()
if not ext in byExt.keys():
byExt[ext]=[]
byExt[ext]=byExt[ext]+[fname]
return byExt
|
def filesByExtension(fnames):
"""given a list of files, return a dict organized by extension."""
byExt={"abf":[],"jpg":[],"tif":[]} # prime it with empties
for fname in fnames:
ext = os.path.splitext(fname)[1].replace(".",'').lower()
if not ext in byExt.keys():
byExt[ext]=[]
byExt[ext]=byExt[ext]+[fname]
return byExt
|
[
"given",
"a",
"list",
"of",
"files",
"return",
"a",
"dict",
"organized",
"by",
"extension",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/indexing/index_OLD.py#L1-L9
|
[
"def",
"filesByExtension",
"(",
"fnames",
")",
":",
"byExt",
"=",
"{",
"\"abf\"",
":",
"[",
"]",
",",
"\"jpg\"",
":",
"[",
"]",
",",
"\"tif\"",
":",
"[",
"]",
"}",
"# prime it with empties",
"for",
"fname",
"in",
"fnames",
":",
"ext",
"=",
"os",
".",
"path",
".",
"splitext",
"(",
"fname",
")",
"[",
"1",
"]",
".",
"replace",
"(",
"\".\"",
",",
"''",
")",
".",
"lower",
"(",
")",
"if",
"not",
"ext",
"in",
"byExt",
".",
"keys",
"(",
")",
":",
"byExt",
"[",
"ext",
"]",
"=",
"[",
"]",
"byExt",
"[",
"ext",
"]",
"=",
"byExt",
"[",
"ext",
"]",
"+",
"[",
"fname",
"]",
"return",
"byExt"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
findCells
|
given a list of files, return a list of cells by their ID.
A cell is indicated when an ABF name matches the start of another file.
Example:
123456.abf
123456-whatever.tif
|
swhlab/indexing/index_OLD.py
|
def findCells(fnames):
"""
given a list of files, return a list of cells by their ID.
A cell is indicated when an ABF name matches the start of another file.
Example:
123456.abf
123456-whatever.tif
"""
IDs=[]
filesByExt = filesByExtension(fnames)
for abfFname in filesByExt['abf']:
ID=os.path.splitext(abfFname)[0]
for picFname in filesByExt['jpg']+filesByExt['tif']:
if picFname.startswith(ID):
IDs.append(ID)
break
return smartSort(IDs)
|
def findCells(fnames):
"""
given a list of files, return a list of cells by their ID.
A cell is indicated when an ABF name matches the start of another file.
Example:
123456.abf
123456-whatever.tif
"""
IDs=[]
filesByExt = filesByExtension(fnames)
for abfFname in filesByExt['abf']:
ID=os.path.splitext(abfFname)[0]
for picFname in filesByExt['jpg']+filesByExt['tif']:
if picFname.startswith(ID):
IDs.append(ID)
break
return smartSort(IDs)
|
[
"given",
"a",
"list",
"of",
"files",
"return",
"a",
"list",
"of",
"cells",
"by",
"their",
"ID",
".",
"A",
"cell",
"is",
"indicated",
"when",
"an",
"ABF",
"name",
"matches",
"the",
"start",
"of",
"another",
"file",
".",
"Example",
":",
"123456",
".",
"abf",
"123456",
"-",
"whatever",
".",
"tif"
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/indexing/index_OLD.py#L11-L28
|
[
"def",
"findCells",
"(",
"fnames",
")",
":",
"IDs",
"=",
"[",
"]",
"filesByExt",
"=",
"filesByExtension",
"(",
"fnames",
")",
"for",
"abfFname",
"in",
"filesByExt",
"[",
"'abf'",
"]",
":",
"ID",
"=",
"os",
".",
"path",
".",
"splitext",
"(",
"abfFname",
")",
"[",
"0",
"]",
"for",
"picFname",
"in",
"filesByExt",
"[",
"'jpg'",
"]",
"+",
"filesByExt",
"[",
"'tif'",
"]",
":",
"if",
"picFname",
".",
"startswith",
"(",
"ID",
")",
":",
"IDs",
".",
"append",
"(",
"ID",
")",
"break",
"return",
"smartSort",
"(",
"IDs",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
filesByCell
|
given files and cells, return a dict of files grouped by cell.
|
swhlab/indexing/index_OLD.py
|
def filesByCell(fnames,cells):
"""given files and cells, return a dict of files grouped by cell."""
byCell={}
fnames=smartSort(fnames)
days = list(set([elem[:5] for elem in fnames if elem.endswith(".abf")])) # so pythonic!
for day in smartSort(days):
parent=None
for i,fname in enumerate([elem for elem in fnames if elem.startswith(day) and elem.endswith(".abf")]):
ID=os.path.splitext(fname)[0]
if len([x for x in fnames if x.startswith(ID)])-1:
parent=ID
if not parent in byCell:
byCell[parent]=[]
byCell[parent]=byCell[parent]+[fname]
return byCell
|
def filesByCell(fnames,cells):
"""given files and cells, return a dict of files grouped by cell."""
byCell={}
fnames=smartSort(fnames)
days = list(set([elem[:5] for elem in fnames if elem.endswith(".abf")])) # so pythonic!
for day in smartSort(days):
parent=None
for i,fname in enumerate([elem for elem in fnames if elem.startswith(day) and elem.endswith(".abf")]):
ID=os.path.splitext(fname)[0]
if len([x for x in fnames if x.startswith(ID)])-1:
parent=ID
if not parent in byCell:
byCell[parent]=[]
byCell[parent]=byCell[parent]+[fname]
return byCell
|
[
"given",
"files",
"and",
"cells",
"return",
"a",
"dict",
"of",
"files",
"grouped",
"by",
"cell",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/indexing/index_OLD.py#L30-L44
|
[
"def",
"filesByCell",
"(",
"fnames",
",",
"cells",
")",
":",
"byCell",
"=",
"{",
"}",
"fnames",
"=",
"smartSort",
"(",
"fnames",
")",
"days",
"=",
"list",
"(",
"set",
"(",
"[",
"elem",
"[",
":",
"5",
"]",
"for",
"elem",
"in",
"fnames",
"if",
"elem",
".",
"endswith",
"(",
"\".abf\"",
")",
"]",
")",
")",
"# so pythonic!",
"for",
"day",
"in",
"smartSort",
"(",
"days",
")",
":",
"parent",
"=",
"None",
"for",
"i",
",",
"fname",
"in",
"enumerate",
"(",
"[",
"elem",
"for",
"elem",
"in",
"fnames",
"if",
"elem",
".",
"startswith",
"(",
"day",
")",
"and",
"elem",
".",
"endswith",
"(",
"\".abf\"",
")",
"]",
")",
":",
"ID",
"=",
"os",
".",
"path",
".",
"splitext",
"(",
"fname",
")",
"[",
"0",
"]",
"if",
"len",
"(",
"[",
"x",
"for",
"x",
"in",
"fnames",
"if",
"x",
".",
"startswith",
"(",
"ID",
")",
"]",
")",
"-",
"1",
":",
"parent",
"=",
"ID",
"if",
"not",
"parent",
"in",
"byCell",
":",
"byCell",
"[",
"parent",
"]",
"=",
"[",
"]",
"byCell",
"[",
"parent",
"]",
"=",
"byCell",
"[",
"parent",
"]",
"+",
"[",
"fname",
"]",
"return",
"byCell"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
ABFindex.folderScan
|
populate class properties relating to files in the folder.
|
swhlab/indexing/index_OLD.py
|
def folderScan(self,abfFolder=None):
"""populate class properties relating to files in the folder."""
if abfFolder is None and 'abfFolder' in dir(self):
abfFolder=self.abfFolder
else:
self.abfFolder=abfFolder
self.abfFolder=os.path.abspath(self.abfFolder)
self.log.info("scanning [%s]",self.abfFolder)
if not os.path.exists(self.abfFolder):
self.log.error("path doesn't exist: [%s]",abfFolder)
return
self.abfFolder2=os.path.abspath(self.abfFolder+"/swhlab/")
if not os.path.exists(self.abfFolder2):
self.log.error("./swhlab/ doesn't exist. creating it...")
os.mkdir(self.abfFolder2)
self.fnames=os.listdir(self.abfFolder)
self.fnames2=os.listdir(self.abfFolder2)
self.log.debug("./ has %d files",len(self.fnames))
self.log.debug("./swhlab/ has %d files",len(self.fnames2))
self.fnamesByExt = filesByExtension(self.fnames)
if not "abf" in self.fnamesByExt.keys():
self.log.error("no ABF files found")
self.log.debug("found %d ABFs",len(self.fnamesByExt["abf"]))
self.cells=findCells(self.fnames) # list of cells by their ID
self.log.debug("found %d cells"%len(self.cells))
self.fnamesByCell = filesByCell(self.fnames,self.cells) # only ABFs
self.log.debug("grouped cells by number of source files: %s"%\
str([len(self.fnamesByCell[elem]) for elem in self.fnamesByCell]))
|
def folderScan(self,abfFolder=None):
"""populate class properties relating to files in the folder."""
if abfFolder is None and 'abfFolder' in dir(self):
abfFolder=self.abfFolder
else:
self.abfFolder=abfFolder
self.abfFolder=os.path.abspath(self.abfFolder)
self.log.info("scanning [%s]",self.abfFolder)
if not os.path.exists(self.abfFolder):
self.log.error("path doesn't exist: [%s]",abfFolder)
return
self.abfFolder2=os.path.abspath(self.abfFolder+"/swhlab/")
if not os.path.exists(self.abfFolder2):
self.log.error("./swhlab/ doesn't exist. creating it...")
os.mkdir(self.abfFolder2)
self.fnames=os.listdir(self.abfFolder)
self.fnames2=os.listdir(self.abfFolder2)
self.log.debug("./ has %d files",len(self.fnames))
self.log.debug("./swhlab/ has %d files",len(self.fnames2))
self.fnamesByExt = filesByExtension(self.fnames)
if not "abf" in self.fnamesByExt.keys():
self.log.error("no ABF files found")
self.log.debug("found %d ABFs",len(self.fnamesByExt["abf"]))
self.cells=findCells(self.fnames) # list of cells by their ID
self.log.debug("found %d cells"%len(self.cells))
self.fnamesByCell = filesByCell(self.fnames,self.cells) # only ABFs
self.log.debug("grouped cells by number of source files: %s"%\
str([len(self.fnamesByCell[elem]) for elem in self.fnamesByCell]))
|
[
"populate",
"class",
"properties",
"relating",
"to",
"files",
"in",
"the",
"folder",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/indexing/index_OLD.py#L76-L105
|
[
"def",
"folderScan",
"(",
"self",
",",
"abfFolder",
"=",
"None",
")",
":",
"if",
"abfFolder",
"is",
"None",
"and",
"'abfFolder'",
"in",
"dir",
"(",
"self",
")",
":",
"abfFolder",
"=",
"self",
".",
"abfFolder",
"else",
":",
"self",
".",
"abfFolder",
"=",
"abfFolder",
"self",
".",
"abfFolder",
"=",
"os",
".",
"path",
".",
"abspath",
"(",
"self",
".",
"abfFolder",
")",
"self",
".",
"log",
".",
"info",
"(",
"\"scanning [%s]\"",
",",
"self",
".",
"abfFolder",
")",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"self",
".",
"abfFolder",
")",
":",
"self",
".",
"log",
".",
"error",
"(",
"\"path doesn't exist: [%s]\"",
",",
"abfFolder",
")",
"return",
"self",
".",
"abfFolder2",
"=",
"os",
".",
"path",
".",
"abspath",
"(",
"self",
".",
"abfFolder",
"+",
"\"/swhlab/\"",
")",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"self",
".",
"abfFolder2",
")",
":",
"self",
".",
"log",
".",
"error",
"(",
"\"./swhlab/ doesn't exist. creating it...\"",
")",
"os",
".",
"mkdir",
"(",
"self",
".",
"abfFolder2",
")",
"self",
".",
"fnames",
"=",
"os",
".",
"listdir",
"(",
"self",
".",
"abfFolder",
")",
"self",
".",
"fnames2",
"=",
"os",
".",
"listdir",
"(",
"self",
".",
"abfFolder2",
")",
"self",
".",
"log",
".",
"debug",
"(",
"\"./ has %d files\"",
",",
"len",
"(",
"self",
".",
"fnames",
")",
")",
"self",
".",
"log",
".",
"debug",
"(",
"\"./swhlab/ has %d files\"",
",",
"len",
"(",
"self",
".",
"fnames2",
")",
")",
"self",
".",
"fnamesByExt",
"=",
"filesByExtension",
"(",
"self",
".",
"fnames",
")",
"if",
"not",
"\"abf\"",
"in",
"self",
".",
"fnamesByExt",
".",
"keys",
"(",
")",
":",
"self",
".",
"log",
".",
"error",
"(",
"\"no ABF files found\"",
")",
"self",
".",
"log",
".",
"debug",
"(",
"\"found %d ABFs\"",
",",
"len",
"(",
"self",
".",
"fnamesByExt",
"[",
"\"abf\"",
"]",
")",
")",
"self",
".",
"cells",
"=",
"findCells",
"(",
"self",
".",
"fnames",
")",
"# list of cells by their ID",
"self",
".",
"log",
".",
"debug",
"(",
"\"found %d cells\"",
"%",
"len",
"(",
"self",
".",
"cells",
")",
")",
"self",
".",
"fnamesByCell",
"=",
"filesByCell",
"(",
"self",
".",
"fnames",
",",
"self",
".",
"cells",
")",
"# only ABFs",
"self",
".",
"log",
".",
"debug",
"(",
"\"grouped cells by number of source files: %s\"",
"%",
"str",
"(",
"[",
"len",
"(",
"self",
".",
"fnamesByCell",
"[",
"elem",
"]",
")",
"for",
"elem",
"in",
"self",
".",
"fnamesByCell",
"]",
")",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
ABFindex.html_index
|
generate list of cells with links. keep this simple.
automatically generates splash page and regnerates frames.
|
swhlab/indexing/index_OLD.py
|
def html_index(self,launch=False,showChildren=False):
"""
generate list of cells with links. keep this simple.
automatically generates splash page and regnerates frames.
"""
self.makePics() # ensure all pics are converted
# generate menu
html='<a href="index_splash.html" target="content">./%s/</a><br>'%os.path.basename(self.abfFolder)
for ID in smartSort(self.fnamesByCell.keys()):
link=''
if ID+".html" in self.fnames2:
link='href="%s.html" target="content"'%ID
html+=('<a %s>%s</a><br>'%(link,ID)) # show the parent ABF (ID)
if showChildren:
for fname in self.fnamesByCell[ID]:
thisID=os.path.splitext(fname)[0]
files2=[x for x in self.fnames2 if x.startswith(thisID) and not x.endswith(".html")]
html+='<i>%s</i>'%thisID # show the child ABF
if len(files2):
html+=' (%s)'%len(files2) # show number of supporting files
html+='<br>'
html+="<br>"
style.save(html,self.abfFolder2+"/index_menu.html")
self.html_index_splash() # make splash page
style.frames(self.abfFolder2+"/index.html",launch=launch)
|
def html_index(self,launch=False,showChildren=False):
"""
generate list of cells with links. keep this simple.
automatically generates splash page and regnerates frames.
"""
self.makePics() # ensure all pics are converted
# generate menu
html='<a href="index_splash.html" target="content">./%s/</a><br>'%os.path.basename(self.abfFolder)
for ID in smartSort(self.fnamesByCell.keys()):
link=''
if ID+".html" in self.fnames2:
link='href="%s.html" target="content"'%ID
html+=('<a %s>%s</a><br>'%(link,ID)) # show the parent ABF (ID)
if showChildren:
for fname in self.fnamesByCell[ID]:
thisID=os.path.splitext(fname)[0]
files2=[x for x in self.fnames2 if x.startswith(thisID) and not x.endswith(".html")]
html+='<i>%s</i>'%thisID # show the child ABF
if len(files2):
html+=' (%s)'%len(files2) # show number of supporting files
html+='<br>'
html+="<br>"
style.save(html,self.abfFolder2+"/index_menu.html")
self.html_index_splash() # make splash page
style.frames(self.abfFolder2+"/index.html",launch=launch)
|
[
"generate",
"list",
"of",
"cells",
"with",
"links",
".",
"keep",
"this",
"simple",
".",
"automatically",
"generates",
"splash",
"page",
"and",
"regnerates",
"frames",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/indexing/index_OLD.py#L107-L131
|
[
"def",
"html_index",
"(",
"self",
",",
"launch",
"=",
"False",
",",
"showChildren",
"=",
"False",
")",
":",
"self",
".",
"makePics",
"(",
")",
"# ensure all pics are converted",
"# generate menu",
"html",
"=",
"'<a href=\"index_splash.html\" target=\"content\">./%s/</a><br>'",
"%",
"os",
".",
"path",
".",
"basename",
"(",
"self",
".",
"abfFolder",
")",
"for",
"ID",
"in",
"smartSort",
"(",
"self",
".",
"fnamesByCell",
".",
"keys",
"(",
")",
")",
":",
"link",
"=",
"''",
"if",
"ID",
"+",
"\".html\"",
"in",
"self",
".",
"fnames2",
":",
"link",
"=",
"'href=\"%s.html\" target=\"content\"'",
"%",
"ID",
"html",
"+=",
"(",
"'<a %s>%s</a><br>'",
"%",
"(",
"link",
",",
"ID",
")",
")",
"# show the parent ABF (ID)",
"if",
"showChildren",
":",
"for",
"fname",
"in",
"self",
".",
"fnamesByCell",
"[",
"ID",
"]",
":",
"thisID",
"=",
"os",
".",
"path",
".",
"splitext",
"(",
"fname",
")",
"[",
"0",
"]",
"files2",
"=",
"[",
"x",
"for",
"x",
"in",
"self",
".",
"fnames2",
"if",
"x",
".",
"startswith",
"(",
"thisID",
")",
"and",
"not",
"x",
".",
"endswith",
"(",
"\".html\"",
")",
"]",
"html",
"+=",
"'<i>%s</i>'",
"%",
"thisID",
"# show the child ABF",
"if",
"len",
"(",
"files2",
")",
":",
"html",
"+=",
"' (%s)'",
"%",
"len",
"(",
"files2",
")",
"# show number of supporting files",
"html",
"+=",
"'<br>'",
"html",
"+=",
"\"<br>\"",
"style",
".",
"save",
"(",
"html",
",",
"self",
".",
"abfFolder2",
"+",
"\"/index_menu.html\"",
")",
"self",
".",
"html_index_splash",
"(",
")",
"# make splash page",
"style",
".",
"frames",
"(",
"self",
".",
"abfFolder2",
"+",
"\"/index.html\"",
",",
"launch",
"=",
"launch",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
ABFindex.html_index_splash
|
generate landing page.
|
swhlab/indexing/index_OLD.py
|
def html_index_splash(self):
"""generate landing page."""
html="""<h1 style="background-color: #EEEEFF; padding: 10px; border: 1px solid #CCCCFF;">
SWHLab <span style="font-size: 35%%;">%s<?span></h1>
"""%version.__version__
#html+='<code>%s</code><br><br>'%self.abfFolder
#html+='<hr>'
for parent in smartSort(self.fnamesByCell.keys()):
html+='<br><b><a href="%s.html">%s</a></b><br>'%(parent,parent)
for child in self.fnamesByCell[parent]:
fullpath=os.path.join(self.abfFolder,child)
protocol = swhlab.swh_abf.abfProtocol(fullpath)
html+='<code>%s[%s]</code><br>'%(fullpath,protocol)
style.save(html,self.abfFolder2+"/index_splash.html")
return
|
def html_index_splash(self):
"""generate landing page."""
html="""<h1 style="background-color: #EEEEFF; padding: 10px; border: 1px solid #CCCCFF;">
SWHLab <span style="font-size: 35%%;">%s<?span></h1>
"""%version.__version__
#html+='<code>%s</code><br><br>'%self.abfFolder
#html+='<hr>'
for parent in smartSort(self.fnamesByCell.keys()):
html+='<br><b><a href="%s.html">%s</a></b><br>'%(parent,parent)
for child in self.fnamesByCell[parent]:
fullpath=os.path.join(self.abfFolder,child)
protocol = swhlab.swh_abf.abfProtocol(fullpath)
html+='<code>%s[%s]</code><br>'%(fullpath,protocol)
style.save(html,self.abfFolder2+"/index_splash.html")
return
|
[
"generate",
"landing",
"page",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/indexing/index_OLD.py#L133-L147
|
[
"def",
"html_index_splash",
"(",
"self",
")",
":",
"html",
"=",
"\"\"\"<h1 style=\"background-color: #EEEEFF; padding: 10px; border: 1px solid #CCCCFF;\">\n SWHLab <span style=\"font-size: 35%%;\">%s<?span></h1>\n \"\"\"",
"%",
"version",
".",
"__version__",
"#html+='<code>%s</code><br><br>'%self.abfFolder",
"#html+='<hr>'",
"for",
"parent",
"in",
"smartSort",
"(",
"self",
".",
"fnamesByCell",
".",
"keys",
"(",
")",
")",
":",
"html",
"+=",
"'<br><b><a href=\"%s.html\">%s</a></b><br>'",
"%",
"(",
"parent",
",",
"parent",
")",
"for",
"child",
"in",
"self",
".",
"fnamesByCell",
"[",
"parent",
"]",
":",
"fullpath",
"=",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"abfFolder",
",",
"child",
")",
"protocol",
"=",
"swhlab",
".",
"swh_abf",
".",
"abfProtocol",
"(",
"fullpath",
")",
"html",
"+=",
"'<code>%s[%s]</code><br>'",
"%",
"(",
"fullpath",
",",
"protocol",
")",
"style",
".",
"save",
"(",
"html",
",",
"self",
".",
"abfFolder2",
"+",
"\"/index_splash.html\"",
")",
"return"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
ABFindex.html_single_basic
|
generate ./swhlab/xxyxxzzz.html for a single given abf.
Input can be an ABF file path of ABF ID.
|
swhlab/indexing/index_OLD.py
|
def html_single_basic(self,ID):
"""
generate ./swhlab/xxyxxzzz.html for a single given abf.
Input can be an ABF file path of ABF ID.
"""
if not ID in self.cells:
self.log.error("ID [%s] not seen!",ID)
return
htmlFname=os.path.abspath(self.abfFolder2+"/"+ID+".html")
html="<h1>Data for ID %s</h1>"%ID
npics=0
for childID in [os.path.splitext(x)[0] for x in self.fnamesByCell[ID]]:
pics=[x for x in self.fnames2 if x.startswith(childID) and os.path.splitext(x)[1].lower() in [".png",".jpg"]]
html+="<code>%s</code><br>"%(os.path.abspath(self.abfFolder+'/'+childID+".abf"))
for i,pic in enumerate(pics):
html+='<a href="%s"><img class="datapic" src="%s" width="200"></a>'%(pic,pic)
npics+=1
html+="<br><br><br>"
style.save(html,htmlFname)
self.log.info("created %s containing %d pictures",htmlFname,npics)
|
def html_single_basic(self,ID):
"""
generate ./swhlab/xxyxxzzz.html for a single given abf.
Input can be an ABF file path of ABF ID.
"""
if not ID in self.cells:
self.log.error("ID [%s] not seen!",ID)
return
htmlFname=os.path.abspath(self.abfFolder2+"/"+ID+".html")
html="<h1>Data for ID %s</h1>"%ID
npics=0
for childID in [os.path.splitext(x)[0] for x in self.fnamesByCell[ID]]:
pics=[x for x in self.fnames2 if x.startswith(childID) and os.path.splitext(x)[1].lower() in [".png",".jpg"]]
html+="<code>%s</code><br>"%(os.path.abspath(self.abfFolder+'/'+childID+".abf"))
for i,pic in enumerate(pics):
html+='<a href="%s"><img class="datapic" src="%s" width="200"></a>'%(pic,pic)
npics+=1
html+="<br><br><br>"
style.save(html,htmlFname)
self.log.info("created %s containing %d pictures",htmlFname,npics)
|
[
"generate",
".",
"/",
"swhlab",
"/",
"xxyxxzzz",
".",
"html",
"for",
"a",
"single",
"given",
"abf",
".",
"Input",
"can",
"be",
"an",
"ABF",
"file",
"path",
"of",
"ABF",
"ID",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/indexing/index_OLD.py#L149-L168
|
[
"def",
"html_single_basic",
"(",
"self",
",",
"ID",
")",
":",
"if",
"not",
"ID",
"in",
"self",
".",
"cells",
":",
"self",
".",
"log",
".",
"error",
"(",
"\"ID [%s] not seen!\"",
",",
"ID",
")",
"return",
"htmlFname",
"=",
"os",
".",
"path",
".",
"abspath",
"(",
"self",
".",
"abfFolder2",
"+",
"\"/\"",
"+",
"ID",
"+",
"\".html\"",
")",
"html",
"=",
"\"<h1>Data for ID %s</h1>\"",
"%",
"ID",
"npics",
"=",
"0",
"for",
"childID",
"in",
"[",
"os",
".",
"path",
".",
"splitext",
"(",
"x",
")",
"[",
"0",
"]",
"for",
"x",
"in",
"self",
".",
"fnamesByCell",
"[",
"ID",
"]",
"]",
":",
"pics",
"=",
"[",
"x",
"for",
"x",
"in",
"self",
".",
"fnames2",
"if",
"x",
".",
"startswith",
"(",
"childID",
")",
"and",
"os",
".",
"path",
".",
"splitext",
"(",
"x",
")",
"[",
"1",
"]",
".",
"lower",
"(",
")",
"in",
"[",
"\".png\"",
",",
"\".jpg\"",
"]",
"]",
"html",
"+=",
"\"<code>%s</code><br>\"",
"%",
"(",
"os",
".",
"path",
".",
"abspath",
"(",
"self",
".",
"abfFolder",
"+",
"'/'",
"+",
"childID",
"+",
"\".abf\"",
")",
")",
"for",
"i",
",",
"pic",
"in",
"enumerate",
"(",
"pics",
")",
":",
"html",
"+=",
"'<a href=\"%s\"><img class=\"datapic\" src=\"%s\" width=\"200\"></a>'",
"%",
"(",
"pic",
",",
"pic",
")",
"npics",
"+=",
"1",
"html",
"+=",
"\"<br><br><br>\"",
"style",
".",
"save",
"(",
"html",
",",
"htmlFname",
")",
"self",
".",
"log",
".",
"info",
"(",
"\"created %s containing %d pictures\"",
",",
"htmlFname",
",",
"npics",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
ABFindex.html_singleAll
|
generate a data view for every ABF in the project folder.
|
swhlab/indexing/index_OLD.py
|
def html_singleAll(self,template="basic"):
"""generate a data view for every ABF in the project folder."""
for fname in smartSort(self.cells):
if template=="fixed":
self.html_single_fixed(fname)
else:
self.html_single_basic(fname)
|
def html_singleAll(self,template="basic"):
"""generate a data view for every ABF in the project folder."""
for fname in smartSort(self.cells):
if template=="fixed":
self.html_single_fixed(fname)
else:
self.html_single_basic(fname)
|
[
"generate",
"a",
"data",
"view",
"for",
"every",
"ABF",
"in",
"the",
"project",
"folder",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/indexing/index_OLD.py#L174-L180
|
[
"def",
"html_singleAll",
"(",
"self",
",",
"template",
"=",
"\"basic\"",
")",
":",
"for",
"fname",
"in",
"smartSort",
"(",
"self",
".",
"cells",
")",
":",
"if",
"template",
"==",
"\"fixed\"",
":",
"self",
".",
"html_single_fixed",
"(",
"fname",
")",
"else",
":",
"self",
".",
"html_single_basic",
"(",
"fname",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
ABFindex.makePics
|
convert every .image we find to a ./swhlab/ image
|
swhlab/indexing/index_OLD.py
|
def makePics(self):
"""convert every .image we find to a ./swhlab/ image"""
rescanNeeded=False
for fname in smartSort(self.fnames):
if fname in self.fnames2:
continue
ext=os.path.splitext(fname)[1].lower()
if ext in [".jpg",".png"]:
if not fname in self.abfFolder2:
self.log.debug("copying %s",fname)
shutil.copy(os.path.join(self.abfFolder,fname),os.path.join(self.abfFolder2,fname))
rescanNeeded=True
if ext in [".tif",".tiff"]:
if not fname+".jpg" in self.fnames2:
self.log.debug("converting %s",fname)
swhlab.swh_image.TIF_to_jpg(os.path.join(self.abfFolder,fname),saveAs=os.path.join(self.abfFolder2,fname+".jpg"))
rescanNeeded=True
if rescanNeeded:
self.log.debug("new pics, so a rescan is needed...")
self.log.debug("REBUILDING ALL RECOMMENDED!!!!!!!!!!!")
self.folderScan()
|
def makePics(self):
"""convert every .image we find to a ./swhlab/ image"""
rescanNeeded=False
for fname in smartSort(self.fnames):
if fname in self.fnames2:
continue
ext=os.path.splitext(fname)[1].lower()
if ext in [".jpg",".png"]:
if not fname in self.abfFolder2:
self.log.debug("copying %s",fname)
shutil.copy(os.path.join(self.abfFolder,fname),os.path.join(self.abfFolder2,fname))
rescanNeeded=True
if ext in [".tif",".tiff"]:
if not fname+".jpg" in self.fnames2:
self.log.debug("converting %s",fname)
swhlab.swh_image.TIF_to_jpg(os.path.join(self.abfFolder,fname),saveAs=os.path.join(self.abfFolder2,fname+".jpg"))
rescanNeeded=True
if rescanNeeded:
self.log.debug("new pics, so a rescan is needed...")
self.log.debug("REBUILDING ALL RECOMMENDED!!!!!!!!!!!")
self.folderScan()
|
[
"convert",
"every",
".",
"image",
"we",
"find",
"to",
"a",
".",
"/",
"swhlab",
"/",
"image"
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/swhlab/indexing/index_OLD.py#L182-L202
|
[
"def",
"makePics",
"(",
"self",
")",
":",
"rescanNeeded",
"=",
"False",
"for",
"fname",
"in",
"smartSort",
"(",
"self",
".",
"fnames",
")",
":",
"if",
"fname",
"in",
"self",
".",
"fnames2",
":",
"continue",
"ext",
"=",
"os",
".",
"path",
".",
"splitext",
"(",
"fname",
")",
"[",
"1",
"]",
".",
"lower",
"(",
")",
"if",
"ext",
"in",
"[",
"\".jpg\"",
",",
"\".png\"",
"]",
":",
"if",
"not",
"fname",
"in",
"self",
".",
"abfFolder2",
":",
"self",
".",
"log",
".",
"debug",
"(",
"\"copying %s\"",
",",
"fname",
")",
"shutil",
".",
"copy",
"(",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"abfFolder",
",",
"fname",
")",
",",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"abfFolder2",
",",
"fname",
")",
")",
"rescanNeeded",
"=",
"True",
"if",
"ext",
"in",
"[",
"\".tif\"",
",",
"\".tiff\"",
"]",
":",
"if",
"not",
"fname",
"+",
"\".jpg\"",
"in",
"self",
".",
"fnames2",
":",
"self",
".",
"log",
".",
"debug",
"(",
"\"converting %s\"",
",",
"fname",
")",
"swhlab",
".",
"swh_image",
".",
"TIF_to_jpg",
"(",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"abfFolder",
",",
"fname",
")",
",",
"saveAs",
"=",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"abfFolder2",
",",
"fname",
"+",
"\".jpg\"",
")",
")",
"rescanNeeded",
"=",
"True",
"if",
"rescanNeeded",
":",
"self",
".",
"log",
".",
"debug",
"(",
"\"new pics, so a rescan is needed...\"",
")",
"self",
".",
"log",
".",
"debug",
"(",
"\"REBUILDING ALL RECOMMENDED!!!!!!!!!!!\"",
")",
"self",
".",
"folderScan",
"(",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
proto_01_01_HP010
|
hyperpolarization step. Use to calculate tau and stuff.
|
doc/oldcode/indexing/standard.py
|
def proto_01_01_HP010(abf=exampleABF):
"""hyperpolarization step. Use to calculate tau and stuff."""
swhlab.memtest.memtest(abf) #knows how to do IC memtest
swhlab.memtest.checkSweep(abf) #lets you eyeball check how it did
swhlab.plot.save(abf,tag="tau")
|
def proto_01_01_HP010(abf=exampleABF):
"""hyperpolarization step. Use to calculate tau and stuff."""
swhlab.memtest.memtest(abf) #knows how to do IC memtest
swhlab.memtest.checkSweep(abf) #lets you eyeball check how it did
swhlab.plot.save(abf,tag="tau")
|
[
"hyperpolarization",
"step",
".",
"Use",
"to",
"calculate",
"tau",
"and",
"stuff",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/indexing/standard.py#L47-L51
|
[
"def",
"proto_01_01_HP010",
"(",
"abf",
"=",
"exampleABF",
")",
":",
"swhlab",
".",
"memtest",
".",
"memtest",
"(",
"abf",
")",
"#knows how to do IC memtest",
"swhlab",
".",
"memtest",
".",
"checkSweep",
"(",
"abf",
")",
"#lets you eyeball check how it did",
"swhlab",
".",
"plot",
".",
"save",
"(",
"abf",
",",
"tag",
"=",
"\"tau\"",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
proto_01_11_rampStep
|
each sweep is a ramp (of set size) which builds on the last sweep.
Used for detection of AP properties from first few APs.
|
doc/oldcode/indexing/standard.py
|
def proto_01_11_rampStep(abf=exampleABF):
"""each sweep is a ramp (of set size) which builds on the last sweep.
Used for detection of AP properties from first few APs."""
standard_inspect(abf)
swhlab.ap.detect(abf)
swhlab.ap.check_sweep(abf) #eyeball how well event detection worked
swhlab.plot.save(abf,tag="check")
swhlab.ap.check_AP_raw(abf) #show overlayed first few APs
swhlab.plot.save(abf,tag="raw",resize=False)
swhlab.ap.check_AP_deriv(abf) #show overlayed first few APs
swhlab.plot.save(abf,tag="deriv")
swhlab.ap.check_AP_phase(abf) #show overlayed first few APs
swhlab.plot.save(abf,tag="phase")
for feature in ['downslope','freq']:
swhlab.ap.plot_values(abf,feature,continuous=True) #plot AP info
swhlab.plot.save(abf,tag=feature)
|
def proto_01_11_rampStep(abf=exampleABF):
"""each sweep is a ramp (of set size) which builds on the last sweep.
Used for detection of AP properties from first few APs."""
standard_inspect(abf)
swhlab.ap.detect(abf)
swhlab.ap.check_sweep(abf) #eyeball how well event detection worked
swhlab.plot.save(abf,tag="check")
swhlab.ap.check_AP_raw(abf) #show overlayed first few APs
swhlab.plot.save(abf,tag="raw",resize=False)
swhlab.ap.check_AP_deriv(abf) #show overlayed first few APs
swhlab.plot.save(abf,tag="deriv")
swhlab.ap.check_AP_phase(abf) #show overlayed first few APs
swhlab.plot.save(abf,tag="phase")
for feature in ['downslope','freq']:
swhlab.ap.plot_values(abf,feature,continuous=True) #plot AP info
swhlab.plot.save(abf,tag=feature)
|
[
"each",
"sweep",
"is",
"a",
"ramp",
"(",
"of",
"set",
"size",
")",
"which",
"builds",
"on",
"the",
"last",
"sweep",
".",
"Used",
"for",
"detection",
"of",
"AP",
"properties",
"from",
"first",
"few",
"APs",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/indexing/standard.py#L53-L68
|
[
"def",
"proto_01_11_rampStep",
"(",
"abf",
"=",
"exampleABF",
")",
":",
"standard_inspect",
"(",
"abf",
")",
"swhlab",
".",
"ap",
".",
"detect",
"(",
"abf",
")",
"swhlab",
".",
"ap",
".",
"check_sweep",
"(",
"abf",
")",
"#eyeball how well event detection worked",
"swhlab",
".",
"plot",
".",
"save",
"(",
"abf",
",",
"tag",
"=",
"\"check\"",
")",
"swhlab",
".",
"ap",
".",
"check_AP_raw",
"(",
"abf",
")",
"#show overlayed first few APs",
"swhlab",
".",
"plot",
".",
"save",
"(",
"abf",
",",
"tag",
"=",
"\"raw\"",
",",
"resize",
"=",
"False",
")",
"swhlab",
".",
"ap",
".",
"check_AP_deriv",
"(",
"abf",
")",
"#show overlayed first few APs",
"swhlab",
".",
"plot",
".",
"save",
"(",
"abf",
",",
"tag",
"=",
"\"deriv\"",
")",
"swhlab",
".",
"ap",
".",
"check_AP_phase",
"(",
"abf",
")",
"#show overlayed first few APs",
"swhlab",
".",
"plot",
".",
"save",
"(",
"abf",
",",
"tag",
"=",
"\"phase\"",
")",
"for",
"feature",
"in",
"[",
"'downslope'",
",",
"'freq'",
"]",
":",
"swhlab",
".",
"ap",
".",
"plot_values",
"(",
"abf",
",",
"feature",
",",
"continuous",
"=",
"True",
")",
"#plot AP info",
"swhlab",
".",
"plot",
".",
"save",
"(",
"abf",
",",
"tag",
"=",
"feature",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
proto_01_12_steps025
|
IC steps. Use to determine gain function.
|
doc/oldcode/indexing/standard.py
|
def proto_01_12_steps025(abf=exampleABF):
"""IC steps. Use to determine gain function."""
swhlab.ap.detect(abf)
standard_groupingForInj(abf,200)
for feature in ['freq','downslope']:
swhlab.ap.plot_values(abf,feature,continuous=False) #plot AP info
swhlab.plot.save(abf,tag='A_'+feature)
swhlab.plot.gain(abf) #easy way to do a gain function!
swhlab.plot.save(abf,tag='05-gain')
|
def proto_01_12_steps025(abf=exampleABF):
"""IC steps. Use to determine gain function."""
swhlab.ap.detect(abf)
standard_groupingForInj(abf,200)
for feature in ['freq','downslope']:
swhlab.ap.plot_values(abf,feature,continuous=False) #plot AP info
swhlab.plot.save(abf,tag='A_'+feature)
swhlab.plot.gain(abf) #easy way to do a gain function!
swhlab.plot.save(abf,tag='05-gain')
|
[
"IC",
"steps",
".",
"Use",
"to",
"determine",
"gain",
"function",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/indexing/standard.py#L70-L80
|
[
"def",
"proto_01_12_steps025",
"(",
"abf",
"=",
"exampleABF",
")",
":",
"swhlab",
".",
"ap",
".",
"detect",
"(",
"abf",
")",
"standard_groupingForInj",
"(",
"abf",
",",
"200",
")",
"for",
"feature",
"in",
"[",
"'freq'",
",",
"'downslope'",
"]",
":",
"swhlab",
".",
"ap",
".",
"plot_values",
"(",
"abf",
",",
"feature",
",",
"continuous",
"=",
"False",
")",
"#plot AP info",
"swhlab",
".",
"plot",
".",
"save",
"(",
"abf",
",",
"tag",
"=",
"'A_'",
"+",
"feature",
")",
"swhlab",
".",
"plot",
".",
"gain",
"(",
"abf",
")",
"#easy way to do a gain function!",
"swhlab",
".",
"plot",
".",
"save",
"(",
"abf",
",",
"tag",
"=",
"'05-gain'",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
proto_01_13_steps025dual
|
IC steps. See how hyperpol. step affects things.
|
doc/oldcode/indexing/standard.py
|
def proto_01_13_steps025dual(abf=exampleABF):
"""IC steps. See how hyperpol. step affects things."""
swhlab.ap.detect(abf)
standard_groupingForInj(abf,200)
for feature in ['freq','downslope']:
swhlab.ap.plot_values(abf,feature,continuous=False) #plot AP info
swhlab.plot.save(abf,tag='A_'+feature)
f1=swhlab.ap.getAvgBySweep(abf,'freq',None,1)
f2=swhlab.ap.getAvgBySweep(abf,'freq',1,None)
f1=np.nan_to_num(f1)
f2=np.nan_to_num(f2)
Xs=abf.clampValues(abf.dataX[int(abf.protoSeqX[1]+.01)])
swhlab.plot.new(abf,title="gain function",xlabel="command current (pA)",
ylabel="average inst. freq. (Hz)")
pylab.plot(Xs,f1,'.-',ms=20,alpha=.5,label="step 1",color='b')
pylab.plot(Xs,f2,'.-',ms=20,alpha=.5,label="step 2",color='r')
pylab.legend(loc='upper left')
pylab.axis([Xs[0],Xs[-1],None,None])
swhlab.plot.save(abf,tag='gain')
|
def proto_01_13_steps025dual(abf=exampleABF):
"""IC steps. See how hyperpol. step affects things."""
swhlab.ap.detect(abf)
standard_groupingForInj(abf,200)
for feature in ['freq','downslope']:
swhlab.ap.plot_values(abf,feature,continuous=False) #plot AP info
swhlab.plot.save(abf,tag='A_'+feature)
f1=swhlab.ap.getAvgBySweep(abf,'freq',None,1)
f2=swhlab.ap.getAvgBySweep(abf,'freq',1,None)
f1=np.nan_to_num(f1)
f2=np.nan_to_num(f2)
Xs=abf.clampValues(abf.dataX[int(abf.protoSeqX[1]+.01)])
swhlab.plot.new(abf,title="gain function",xlabel="command current (pA)",
ylabel="average inst. freq. (Hz)")
pylab.plot(Xs,f1,'.-',ms=20,alpha=.5,label="step 1",color='b')
pylab.plot(Xs,f2,'.-',ms=20,alpha=.5,label="step 2",color='r')
pylab.legend(loc='upper left')
pylab.axis([Xs[0],Xs[-1],None,None])
swhlab.plot.save(abf,tag='gain')
|
[
"IC",
"steps",
".",
"See",
"how",
"hyperpol",
".",
"step",
"affects",
"things",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/indexing/standard.py#L86-L106
|
[
"def",
"proto_01_13_steps025dual",
"(",
"abf",
"=",
"exampleABF",
")",
":",
"swhlab",
".",
"ap",
".",
"detect",
"(",
"abf",
")",
"standard_groupingForInj",
"(",
"abf",
",",
"200",
")",
"for",
"feature",
"in",
"[",
"'freq'",
",",
"'downslope'",
"]",
":",
"swhlab",
".",
"ap",
".",
"plot_values",
"(",
"abf",
",",
"feature",
",",
"continuous",
"=",
"False",
")",
"#plot AP info",
"swhlab",
".",
"plot",
".",
"save",
"(",
"abf",
",",
"tag",
"=",
"'A_'",
"+",
"feature",
")",
"f1",
"=",
"swhlab",
".",
"ap",
".",
"getAvgBySweep",
"(",
"abf",
",",
"'freq'",
",",
"None",
",",
"1",
")",
"f2",
"=",
"swhlab",
".",
"ap",
".",
"getAvgBySweep",
"(",
"abf",
",",
"'freq'",
",",
"1",
",",
"None",
")",
"f1",
"=",
"np",
".",
"nan_to_num",
"(",
"f1",
")",
"f2",
"=",
"np",
".",
"nan_to_num",
"(",
"f2",
")",
"Xs",
"=",
"abf",
".",
"clampValues",
"(",
"abf",
".",
"dataX",
"[",
"int",
"(",
"abf",
".",
"protoSeqX",
"[",
"1",
"]",
"+",
".01",
")",
"]",
")",
"swhlab",
".",
"plot",
".",
"new",
"(",
"abf",
",",
"title",
"=",
"\"gain function\"",
",",
"xlabel",
"=",
"\"command current (pA)\"",
",",
"ylabel",
"=",
"\"average inst. freq. (Hz)\"",
")",
"pylab",
".",
"plot",
"(",
"Xs",
",",
"f1",
",",
"'.-'",
",",
"ms",
"=",
"20",
",",
"alpha",
"=",
".5",
",",
"label",
"=",
"\"step 1\"",
",",
"color",
"=",
"'b'",
")",
"pylab",
".",
"plot",
"(",
"Xs",
",",
"f2",
",",
"'.-'",
",",
"ms",
"=",
"20",
",",
"alpha",
"=",
".5",
",",
"label",
"=",
"\"step 2\"",
",",
"color",
"=",
"'r'",
")",
"pylab",
".",
"legend",
"(",
"loc",
"=",
"'upper left'",
")",
"pylab",
".",
"axis",
"(",
"[",
"Xs",
"[",
"0",
"]",
",",
"Xs",
"[",
"-",
"1",
"]",
",",
"None",
",",
"None",
"]",
")",
"swhlab",
".",
"plot",
".",
"save",
"(",
"abf",
",",
"tag",
"=",
"'gain'",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
proto_02_01_MT70
|
repeated membrane tests.
|
doc/oldcode/indexing/standard.py
|
def proto_02_01_MT70(abf=exampleABF):
"""repeated membrane tests."""
standard_overlayWithAverage(abf)
swhlab.memtest.memtest(abf)
swhlab.memtest.checkSweep(abf)
swhlab.plot.save(abf,tag='check',resize=False)
|
def proto_02_01_MT70(abf=exampleABF):
"""repeated membrane tests."""
standard_overlayWithAverage(abf)
swhlab.memtest.memtest(abf)
swhlab.memtest.checkSweep(abf)
swhlab.plot.save(abf,tag='check',resize=False)
|
[
"repeated",
"membrane",
"tests",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/indexing/standard.py#L109-L114
|
[
"def",
"proto_02_01_MT70",
"(",
"abf",
"=",
"exampleABF",
")",
":",
"standard_overlayWithAverage",
"(",
"abf",
")",
"swhlab",
".",
"memtest",
".",
"memtest",
"(",
"abf",
")",
"swhlab",
".",
"memtest",
".",
"checkSweep",
"(",
"abf",
")",
"swhlab",
".",
"plot",
".",
"save",
"(",
"abf",
",",
"tag",
"=",
"'check'",
",",
"resize",
"=",
"False",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
proto_02_02_IVdual
|
dual I/V steps in VC mode, one from -70 and one -50.
|
doc/oldcode/indexing/standard.py
|
def proto_02_02_IVdual(abf=exampleABF):
"""dual I/V steps in VC mode, one from -70 and one -50."""
av1,sd1=swhlab.plot.IV(abf,.7,1,True,'b')
swhlab.plot.save(abf,tag='iv1')
a2v,sd2=swhlab.plot.IV(abf,2.2,2.5,True,'r')
swhlab.plot.save(abf,tag='iv2')
swhlab.plot.sweep(abf,'all')
pylab.axis([None,None,min(av1)-50,max(av1)+50])
swhlab.plot.save(abf,tag='overlay')
|
def proto_02_02_IVdual(abf=exampleABF):
"""dual I/V steps in VC mode, one from -70 and one -50."""
av1,sd1=swhlab.plot.IV(abf,.7,1,True,'b')
swhlab.plot.save(abf,tag='iv1')
a2v,sd2=swhlab.plot.IV(abf,2.2,2.5,True,'r')
swhlab.plot.save(abf,tag='iv2')
swhlab.plot.sweep(abf,'all')
pylab.axis([None,None,min(av1)-50,max(av1)+50])
swhlab.plot.save(abf,tag='overlay')
|
[
"dual",
"I",
"/",
"V",
"steps",
"in",
"VC",
"mode",
"one",
"from",
"-",
"70",
"and",
"one",
"-",
"50",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/indexing/standard.py#L116-L126
|
[
"def",
"proto_02_02_IVdual",
"(",
"abf",
"=",
"exampleABF",
")",
":",
"av1",
",",
"sd1",
"=",
"swhlab",
".",
"plot",
".",
"IV",
"(",
"abf",
",",
".7",
",",
"1",
",",
"True",
",",
"'b'",
")",
"swhlab",
".",
"plot",
".",
"save",
"(",
"abf",
",",
"tag",
"=",
"'iv1'",
")",
"a2v",
",",
"sd2",
"=",
"swhlab",
".",
"plot",
".",
"IV",
"(",
"abf",
",",
"2.2",
",",
"2.5",
",",
"True",
",",
"'r'",
")",
"swhlab",
".",
"plot",
".",
"save",
"(",
"abf",
",",
"tag",
"=",
"'iv2'",
")",
"swhlab",
".",
"plot",
".",
"sweep",
"(",
"abf",
",",
"'all'",
")",
"pylab",
".",
"axis",
"(",
"[",
"None",
",",
"None",
",",
"min",
"(",
"av1",
")",
"-",
"50",
",",
"max",
"(",
"av1",
")",
"+",
"50",
"]",
")",
"swhlab",
".",
"plot",
".",
"save",
"(",
"abf",
",",
"tag",
"=",
"'overlay'",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
proto_02_03_IVfast
|
fast sweeps, 1 step per sweep, for clean IV without fast currents.
|
doc/oldcode/indexing/standard.py
|
def proto_02_03_IVfast(abf=exampleABF):
"""fast sweeps, 1 step per sweep, for clean IV without fast currents."""
av1,sd1=swhlab.plot.IV(abf,.6,.9,True)
swhlab.plot.save(abf,tag='iv1')
Xs=abf.clampValues(.6) #generate IV clamp values
abf.saveThing([Xs,av1],'iv')
|
def proto_02_03_IVfast(abf=exampleABF):
"""fast sweeps, 1 step per sweep, for clean IV without fast currents."""
av1,sd1=swhlab.plot.IV(abf,.6,.9,True)
swhlab.plot.save(abf,tag='iv1')
Xs=abf.clampValues(.6) #generate IV clamp values
abf.saveThing([Xs,av1],'iv')
|
[
"fast",
"sweeps",
"1",
"step",
"per",
"sweep",
"for",
"clean",
"IV",
"without",
"fast",
"currents",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/indexing/standard.py#L128-L133
|
[
"def",
"proto_02_03_IVfast",
"(",
"abf",
"=",
"exampleABF",
")",
":",
"av1",
",",
"sd1",
"=",
"swhlab",
".",
"plot",
".",
"IV",
"(",
"abf",
",",
".6",
",",
".9",
",",
"True",
")",
"swhlab",
".",
"plot",
".",
"save",
"(",
"abf",
",",
"tag",
"=",
"'iv1'",
")",
"Xs",
"=",
"abf",
".",
"clampValues",
"(",
".6",
")",
"#generate IV clamp values",
"abf",
".",
"saveThing",
"(",
"[",
"Xs",
",",
"av1",
"]",
",",
"'iv'",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
proto_04_01_MTmon70s2
|
repeated membrane tests, likely with drug added. Maybe IPSCs.
|
doc/oldcode/indexing/standard.py
|
def proto_04_01_MTmon70s2(abf=exampleABF):
"""repeated membrane tests, likely with drug added. Maybe IPSCs."""
standard_inspect(abf)
swhlab.memtest.memtest(abf)
swhlab.memtest.checkSweep(abf)
swhlab.plot.save(abf,tag='check',resize=False)
swhlab.memtest.plot_standard4(abf)
swhlab.plot.save(abf,tag='memtests')
|
def proto_04_01_MTmon70s2(abf=exampleABF):
"""repeated membrane tests, likely with drug added. Maybe IPSCs."""
standard_inspect(abf)
swhlab.memtest.memtest(abf)
swhlab.memtest.checkSweep(abf)
swhlab.plot.save(abf,tag='check',resize=False)
swhlab.memtest.plot_standard4(abf)
swhlab.plot.save(abf,tag='memtests')
|
[
"repeated",
"membrane",
"tests",
"likely",
"with",
"drug",
"added",
".",
"Maybe",
"IPSCs",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/indexing/standard.py#L139-L146
|
[
"def",
"proto_04_01_MTmon70s2",
"(",
"abf",
"=",
"exampleABF",
")",
":",
"standard_inspect",
"(",
"abf",
")",
"swhlab",
".",
"memtest",
".",
"memtest",
"(",
"abf",
")",
"swhlab",
".",
"memtest",
".",
"checkSweep",
"(",
"abf",
")",
"swhlab",
".",
"plot",
".",
"save",
"(",
"abf",
",",
"tag",
"=",
"'check'",
",",
"resize",
"=",
"False",
")",
"swhlab",
".",
"memtest",
".",
"plot_standard4",
"(",
"abf",
")",
"swhlab",
".",
"plot",
".",
"save",
"(",
"abf",
",",
"tag",
"=",
"'memtests'",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
proto_VC_50_MT_IV
|
combination of membrane test and IV steps.
|
doc/oldcode/indexing/standard.py
|
def proto_VC_50_MT_IV(abf=exampleABF):
"""combination of membrane test and IV steps."""
swhlab.memtest.memtest(abf) #do membrane test on every sweep
swhlab.memtest.checkSweep(abf) #see all MT values
swhlab.plot.save(abf,tag='02-check',resize=False)
av1,sd1=swhlab.plot.IV(abf,1.2,1.4,True,'b')
swhlab.plot.save(abf,tag='iv')
Xs=abf.clampValues(1.2) #generate IV clamp values
abf.saveThing([Xs,av1],'01_iv')
|
def proto_VC_50_MT_IV(abf=exampleABF):
"""combination of membrane test and IV steps."""
swhlab.memtest.memtest(abf) #do membrane test on every sweep
swhlab.memtest.checkSweep(abf) #see all MT values
swhlab.plot.save(abf,tag='02-check',resize=False)
av1,sd1=swhlab.plot.IV(abf,1.2,1.4,True,'b')
swhlab.plot.save(abf,tag='iv')
Xs=abf.clampValues(1.2) #generate IV clamp values
abf.saveThing([Xs,av1],'01_iv')
|
[
"combination",
"of",
"membrane",
"test",
"and",
"IV",
"steps",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/indexing/standard.py#L153-L162
|
[
"def",
"proto_VC_50_MT_IV",
"(",
"abf",
"=",
"exampleABF",
")",
":",
"swhlab",
".",
"memtest",
".",
"memtest",
"(",
"abf",
")",
"#do membrane test on every sweep",
"swhlab",
".",
"memtest",
".",
"checkSweep",
"(",
"abf",
")",
"#see all MT values",
"swhlab",
".",
"plot",
".",
"save",
"(",
"abf",
",",
"tag",
"=",
"'02-check'",
",",
"resize",
"=",
"False",
")",
"av1",
",",
"sd1",
"=",
"swhlab",
".",
"plot",
".",
"IV",
"(",
"abf",
",",
"1.2",
",",
"1.4",
",",
"True",
",",
"'b'",
")",
"swhlab",
".",
"plot",
".",
"save",
"(",
"abf",
",",
"tag",
"=",
"'iv'",
")",
"Xs",
"=",
"abf",
".",
"clampValues",
"(",
"1.2",
")",
"#generate IV clamp values",
"abf",
".",
"saveThing",
"(",
"[",
"Xs",
",",
"av1",
"]",
",",
"'01_iv'",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
proto_IC_ramp_gain
|
increasing ramps in (?) pA steps.
|
doc/oldcode/indexing/standard.py
|
def proto_IC_ramp_gain(abf=exampleABF):
"""increasing ramps in (?) pA steps."""
standard_inspect(abf)
swhlab.ap.detect(abf)
swhlab.ap.check_AP_raw(abf) #show overlayed first few APs
swhlab.plot.save(abf,tag="01-raw",resize=False)
swhlab.ap.check_AP_deriv(abf) #show overlayed first few APs
swhlab.plot.save(abf,tag="02-deriv")
swhlab.ap.check_AP_phase(abf) #show overlayed first few APs
swhlab.plot.save(abf,tag="03-phase")
swhlab.ap.plot_values(abf,'freq',continuous=True) #plot AP info
pylab.subplot(211)
pylab.axhline(40,color='r',lw=2,ls="--",alpha=.2)
swhlab.plot.save(abf,tag='04-freq')
swhlab.ap.plot_values(abf,'downslope',continuous=True) #plot AP info
pylab.subplot(211)
pylab.axhline(-100,color='r',lw=2,ls="--",alpha=.2)
swhlab.plot.save(abf,tag='04-downslope')
|
def proto_IC_ramp_gain(abf=exampleABF):
"""increasing ramps in (?) pA steps."""
standard_inspect(abf)
swhlab.ap.detect(abf)
swhlab.ap.check_AP_raw(abf) #show overlayed first few APs
swhlab.plot.save(abf,tag="01-raw",resize=False)
swhlab.ap.check_AP_deriv(abf) #show overlayed first few APs
swhlab.plot.save(abf,tag="02-deriv")
swhlab.ap.check_AP_phase(abf) #show overlayed first few APs
swhlab.plot.save(abf,tag="03-phase")
swhlab.ap.plot_values(abf,'freq',continuous=True) #plot AP info
pylab.subplot(211)
pylab.axhline(40,color='r',lw=2,ls="--",alpha=.2)
swhlab.plot.save(abf,tag='04-freq')
swhlab.ap.plot_values(abf,'downslope',continuous=True) #plot AP info
pylab.subplot(211)
pylab.axhline(-100,color='r',lw=2,ls="--",alpha=.2)
swhlab.plot.save(abf,tag='04-downslope')
|
[
"increasing",
"ramps",
"in",
"(",
"?",
")",
"pA",
"steps",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/indexing/standard.py#L164-L184
|
[
"def",
"proto_IC_ramp_gain",
"(",
"abf",
"=",
"exampleABF",
")",
":",
"standard_inspect",
"(",
"abf",
")",
"swhlab",
".",
"ap",
".",
"detect",
"(",
"abf",
")",
"swhlab",
".",
"ap",
".",
"check_AP_raw",
"(",
"abf",
")",
"#show overlayed first few APs",
"swhlab",
".",
"plot",
".",
"save",
"(",
"abf",
",",
"tag",
"=",
"\"01-raw\"",
",",
"resize",
"=",
"False",
")",
"swhlab",
".",
"ap",
".",
"check_AP_deriv",
"(",
"abf",
")",
"#show overlayed first few APs",
"swhlab",
".",
"plot",
".",
"save",
"(",
"abf",
",",
"tag",
"=",
"\"02-deriv\"",
")",
"swhlab",
".",
"ap",
".",
"check_AP_phase",
"(",
"abf",
")",
"#show overlayed first few APs",
"swhlab",
".",
"plot",
".",
"save",
"(",
"abf",
",",
"tag",
"=",
"\"03-phase\"",
")",
"swhlab",
".",
"ap",
".",
"plot_values",
"(",
"abf",
",",
"'freq'",
",",
"continuous",
"=",
"True",
")",
"#plot AP info",
"pylab",
".",
"subplot",
"(",
"211",
")",
"pylab",
".",
"axhline",
"(",
"40",
",",
"color",
"=",
"'r'",
",",
"lw",
"=",
"2",
",",
"ls",
"=",
"\"--\"",
",",
"alpha",
"=",
".2",
")",
"swhlab",
".",
"plot",
".",
"save",
"(",
"abf",
",",
"tag",
"=",
"'04-freq'",
")",
"swhlab",
".",
"ap",
".",
"plot_values",
"(",
"abf",
",",
"'downslope'",
",",
"continuous",
"=",
"True",
")",
"#plot AP info",
"pylab",
".",
"subplot",
"(",
"211",
")",
"pylab",
".",
"axhline",
"(",
"-",
"100",
",",
"color",
"=",
"'r'",
",",
"lw",
"=",
"2",
",",
"ls",
"=",
"\"--\"",
",",
"alpha",
"=",
".2",
")",
"swhlab",
".",
"plot",
".",
"save",
"(",
"abf",
",",
"tag",
"=",
"'04-downslope'",
")"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
indexImages
|
OBSOLETE WAY TO INDEX A FOLDER.
|
doc/oldcode/indexing/standard.py
|
def indexImages(folder,fname="index.html"):
"""OBSOLETE WAY TO INDEX A FOLDER.""" #TODO: REMOVE
html="<html><body>"
for item in glob.glob(folder+"/*.*"):
if item.split(".")[-1] in ['jpg','png']:
html+="<h3>%s</h3>"%os.path.basename(item)
html+='<img src="%s">'%os.path.basename(item)
html+='<br>'*10
html+="</html></body>"
f=open(folder+"/"+fname,'w')
f.write(html)
f.close
print("indexed:")
print(" ",os.path.abspath(folder+"/"+fname))
return
|
def indexImages(folder,fname="index.html"):
"""OBSOLETE WAY TO INDEX A FOLDER.""" #TODO: REMOVE
html="<html><body>"
for item in glob.glob(folder+"/*.*"):
if item.split(".")[-1] in ['jpg','png']:
html+="<h3>%s</h3>"%os.path.basename(item)
html+='<img src="%s">'%os.path.basename(item)
html+='<br>'*10
html+="</html></body>"
f=open(folder+"/"+fname,'w')
f.write(html)
f.close
print("indexed:")
print(" ",os.path.abspath(folder+"/"+fname))
return
|
[
"OBSOLETE",
"WAY",
"TO",
"INDEX",
"A",
"FOLDER",
"."
] |
swharden/SWHLab
|
python
|
https://github.com/swharden/SWHLab/blob/a86c3c65323cec809a4bd4f81919644927094bf5/doc/oldcode/indexing/standard.py#L283-L297
|
[
"def",
"indexImages",
"(",
"folder",
",",
"fname",
"=",
"\"index.html\"",
")",
":",
"#TODO: REMOVE",
"html",
"=",
"\"<html><body>\"",
"for",
"item",
"in",
"glob",
".",
"glob",
"(",
"folder",
"+",
"\"/*.*\"",
")",
":",
"if",
"item",
".",
"split",
"(",
"\".\"",
")",
"[",
"-",
"1",
"]",
"in",
"[",
"'jpg'",
",",
"'png'",
"]",
":",
"html",
"+=",
"\"<h3>%s</h3>\"",
"%",
"os",
".",
"path",
".",
"basename",
"(",
"item",
")",
"html",
"+=",
"'<img src=\"%s\">'",
"%",
"os",
".",
"path",
".",
"basename",
"(",
"item",
")",
"html",
"+=",
"'<br>'",
"*",
"10",
"html",
"+=",
"\"</html></body>\"",
"f",
"=",
"open",
"(",
"folder",
"+",
"\"/\"",
"+",
"fname",
",",
"'w'",
")",
"f",
".",
"write",
"(",
"html",
")",
"f",
".",
"close",
"print",
"(",
"\"indexed:\"",
")",
"print",
"(",
"\" \"",
",",
"os",
".",
"path",
".",
"abspath",
"(",
"folder",
"+",
"\"/\"",
"+",
"fname",
")",
")",
"return"
] |
a86c3c65323cec809a4bd4f81919644927094bf5
|
valid
|
BaseActivatableModel.save
|
A custom save method that handles figuring out when something is activated or deactivated.
|
activatable_model/models.py
|
def save(self, *args, **kwargs):
"""
A custom save method that handles figuring out when something is activated or deactivated.
"""
current_activable_value = getattr(self, self.ACTIVATABLE_FIELD_NAME)
is_active_changed = self.id is None or self.__original_activatable_value != current_activable_value
self.__original_activatable_value = current_activable_value
ret_val = super(BaseActivatableModel, self).save(*args, **kwargs)
# Emit the signals for when the is_active flag is changed
if is_active_changed:
model_activations_changed.send(self.__class__, instance_ids=[self.id], is_active=current_activable_value)
if self.activatable_field_updated:
model_activations_updated.send(self.__class__, instance_ids=[self.id], is_active=current_activable_value)
return ret_val
|
def save(self, *args, **kwargs):
"""
A custom save method that handles figuring out when something is activated or deactivated.
"""
current_activable_value = getattr(self, self.ACTIVATABLE_FIELD_NAME)
is_active_changed = self.id is None or self.__original_activatable_value != current_activable_value
self.__original_activatable_value = current_activable_value
ret_val = super(BaseActivatableModel, self).save(*args, **kwargs)
# Emit the signals for when the is_active flag is changed
if is_active_changed:
model_activations_changed.send(self.__class__, instance_ids=[self.id], is_active=current_activable_value)
if self.activatable_field_updated:
model_activations_updated.send(self.__class__, instance_ids=[self.id], is_active=current_activable_value)
return ret_val
|
[
"A",
"custom",
"save",
"method",
"that",
"handles",
"figuring",
"out",
"when",
"something",
"is",
"activated",
"or",
"deactivated",
"."
] |
ambitioninc/django-activatable-model
|
python
|
https://github.com/ambitioninc/django-activatable-model/blob/2c142430949a923a69201f4914a6b73a642b4b48/activatable_model/models.py#L97-L113
|
[
"def",
"save",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"current_activable_value",
"=",
"getattr",
"(",
"self",
",",
"self",
".",
"ACTIVATABLE_FIELD_NAME",
")",
"is_active_changed",
"=",
"self",
".",
"id",
"is",
"None",
"or",
"self",
".",
"__original_activatable_value",
"!=",
"current_activable_value",
"self",
".",
"__original_activatable_value",
"=",
"current_activable_value",
"ret_val",
"=",
"super",
"(",
"BaseActivatableModel",
",",
"self",
")",
".",
"save",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"# Emit the signals for when the is_active flag is changed",
"if",
"is_active_changed",
":",
"model_activations_changed",
".",
"send",
"(",
"self",
".",
"__class__",
",",
"instance_ids",
"=",
"[",
"self",
".",
"id",
"]",
",",
"is_active",
"=",
"current_activable_value",
")",
"if",
"self",
".",
"activatable_field_updated",
":",
"model_activations_updated",
".",
"send",
"(",
"self",
".",
"__class__",
",",
"instance_ids",
"=",
"[",
"self",
".",
"id",
"]",
",",
"is_active",
"=",
"current_activable_value",
")",
"return",
"ret_val"
] |
2c142430949a923a69201f4914a6b73a642b4b48
|
valid
|
BaseActivatableModel.delete
|
It is impossible to delete an activatable model unless force is True. This function instead sets it to inactive.
|
activatable_model/models.py
|
def delete(self, force=False, **kwargs):
"""
It is impossible to delete an activatable model unless force is True. This function instead sets it to inactive.
"""
if force:
return super(BaseActivatableModel, self).delete(**kwargs)
else:
setattr(self, self.ACTIVATABLE_FIELD_NAME, False)
return self.save(update_fields=[self.ACTIVATABLE_FIELD_NAME])
|
def delete(self, force=False, **kwargs):
"""
It is impossible to delete an activatable model unless force is True. This function instead sets it to inactive.
"""
if force:
return super(BaseActivatableModel, self).delete(**kwargs)
else:
setattr(self, self.ACTIVATABLE_FIELD_NAME, False)
return self.save(update_fields=[self.ACTIVATABLE_FIELD_NAME])
|
[
"It",
"is",
"impossible",
"to",
"delete",
"an",
"activatable",
"model",
"unless",
"force",
"is",
"True",
".",
"This",
"function",
"instead",
"sets",
"it",
"to",
"inactive",
"."
] |
ambitioninc/django-activatable-model
|
python
|
https://github.com/ambitioninc/django-activatable-model/blob/2c142430949a923a69201f4914a6b73a642b4b48/activatable_model/models.py#L115-L123
|
[
"def",
"delete",
"(",
"self",
",",
"force",
"=",
"False",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"force",
":",
"return",
"super",
"(",
"BaseActivatableModel",
",",
"self",
")",
".",
"delete",
"(",
"*",
"*",
"kwargs",
")",
"else",
":",
"setattr",
"(",
"self",
",",
"self",
".",
"ACTIVATABLE_FIELD_NAME",
",",
"False",
")",
"return",
"self",
".",
"save",
"(",
"update_fields",
"=",
"[",
"self",
".",
"ACTIVATABLE_FIELD_NAME",
"]",
")"
] |
2c142430949a923a69201f4914a6b73a642b4b48
|
valid
|
Command.show
|
Write to file_handle if supplied, othewise print output
|
lancet/launch.py
|
def show(self, args, file_handle=None, **kwargs):
"Write to file_handle if supplied, othewise print output"
full_string = ''
info = {'root_directory': '<root_directory>',
'batch_name': '<batch_name>',
'batch_tag': '<batch_tag>',
'batch_description': '<batch_description>',
'launcher': '<launcher>',
'timestamp_format': '<timestamp_format>',
'timestamp': tuple(time.localtime()),
'varying_keys': args.varying_keys,
'constant_keys': args.constant_keys,
'constant_items': args.constant_items}
quoted_cmds = [ subprocess.list2cmdline(
[el for el in self(self._formatter(s),'<tid>',info)])
for s in args.specs]
cmd_lines = ['%d: %s\n' % (i, qcmds) for (i,qcmds)
in enumerate(quoted_cmds)]
full_string += ''.join(cmd_lines)
if file_handle:
file_handle.write(full_string)
file_handle.flush()
else:
print(full_string)
|
def show(self, args, file_handle=None, **kwargs):
"Write to file_handle if supplied, othewise print output"
full_string = ''
info = {'root_directory': '<root_directory>',
'batch_name': '<batch_name>',
'batch_tag': '<batch_tag>',
'batch_description': '<batch_description>',
'launcher': '<launcher>',
'timestamp_format': '<timestamp_format>',
'timestamp': tuple(time.localtime()),
'varying_keys': args.varying_keys,
'constant_keys': args.constant_keys,
'constant_items': args.constant_items}
quoted_cmds = [ subprocess.list2cmdline(
[el for el in self(self._formatter(s),'<tid>',info)])
for s in args.specs]
cmd_lines = ['%d: %s\n' % (i, qcmds) for (i,qcmds)
in enumerate(quoted_cmds)]
full_string += ''.join(cmd_lines)
if file_handle:
file_handle.write(full_string)
file_handle.flush()
else:
print(full_string)
|
[
"Write",
"to",
"file_handle",
"if",
"supplied",
"othewise",
"print",
"output"
] |
ioam/lancet
|
python
|
https://github.com/ioam/lancet/blob/1fbbf88fa0e8974ff9ed462e3cb11722ddebdd6e/lancet/launch.py#L72-L97
|
[
"def",
"show",
"(",
"self",
",",
"args",
",",
"file_handle",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"full_string",
"=",
"''",
"info",
"=",
"{",
"'root_directory'",
":",
"'<root_directory>'",
",",
"'batch_name'",
":",
"'<batch_name>'",
",",
"'batch_tag'",
":",
"'<batch_tag>'",
",",
"'batch_description'",
":",
"'<batch_description>'",
",",
"'launcher'",
":",
"'<launcher>'",
",",
"'timestamp_format'",
":",
"'<timestamp_format>'",
",",
"'timestamp'",
":",
"tuple",
"(",
"time",
".",
"localtime",
"(",
")",
")",
",",
"'varying_keys'",
":",
"args",
".",
"varying_keys",
",",
"'constant_keys'",
":",
"args",
".",
"constant_keys",
",",
"'constant_items'",
":",
"args",
".",
"constant_items",
"}",
"quoted_cmds",
"=",
"[",
"subprocess",
".",
"list2cmdline",
"(",
"[",
"el",
"for",
"el",
"in",
"self",
"(",
"self",
".",
"_formatter",
"(",
"s",
")",
",",
"'<tid>'",
",",
"info",
")",
"]",
")",
"for",
"s",
"in",
"args",
".",
"specs",
"]",
"cmd_lines",
"=",
"[",
"'%d: %s\\n'",
"%",
"(",
"i",
",",
"qcmds",
")",
"for",
"(",
"i",
",",
"qcmds",
")",
"in",
"enumerate",
"(",
"quoted_cmds",
")",
"]",
"full_string",
"+=",
"''",
".",
"join",
"(",
"cmd_lines",
")",
"if",
"file_handle",
":",
"file_handle",
".",
"write",
"(",
"full_string",
")",
"file_handle",
".",
"flush",
"(",
")",
"else",
":",
"print",
"(",
"full_string",
")"
] |
1fbbf88fa0e8974ff9ed462e3cb11722ddebdd6e
|
valid
|
Output.update
|
Update the launch information -- use if additional launches were
made.
|
lancet/launch.py
|
def update(self):
"""Update the launch information -- use if additional launches were
made.
"""
launches = []
for path in os.listdir(self.output_dir):
full_path = os.path.join(self.output_dir, path)
if os.path.isdir(full_path):
launches.append(self._get_launch_info(full_path))
self.launches = sorted(launches)
|
def update(self):
"""Update the launch information -- use if additional launches were
made.
"""
launches = []
for path in os.listdir(self.output_dir):
full_path = os.path.join(self.output_dir, path)
if os.path.isdir(full_path):
launches.append(self._get_launch_info(full_path))
self.launches = sorted(launches)
|
[
"Update",
"the",
"launch",
"information",
"--",
"use",
"if",
"additional",
"launches",
"were",
"made",
"."
] |
ioam/lancet
|
python
|
https://github.com/ioam/lancet/blob/1fbbf88fa0e8974ff9ed462e3cb11722ddebdd6e/lancet/launch.py#L363-L372
|
[
"def",
"update",
"(",
"self",
")",
":",
"launches",
"=",
"[",
"]",
"for",
"path",
"in",
"os",
".",
"listdir",
"(",
"self",
".",
"output_dir",
")",
":",
"full_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"output_dir",
",",
"path",
")",
"if",
"os",
".",
"path",
".",
"isdir",
"(",
"full_path",
")",
":",
"launches",
".",
"append",
"(",
"self",
".",
"_get_launch_info",
"(",
"full_path",
")",
")",
"self",
".",
"launches",
"=",
"sorted",
"(",
"launches",
")"
] |
1fbbf88fa0e8974ff9ed462e3cb11722ddebdd6e
|
valid
|
Launcher.get_root_directory
|
A helper method that supplies the root directory name given a
timestamp.
|
lancet/launch.py
|
def get_root_directory(self, timestamp=None):
"""
A helper method that supplies the root directory name given a
timestamp.
"""
if timestamp is None: timestamp = self.timestamp
if self.timestamp_format is not None:
root_name = (time.strftime(self.timestamp_format, timestamp)
+ '-' + self.batch_name)
else:
root_name = self.batch_name
path = os.path.join(self.output_directory,
*(self.subdir+[root_name]))
return os.path.abspath(path)
|
def get_root_directory(self, timestamp=None):
"""
A helper method that supplies the root directory name given a
timestamp.
"""
if timestamp is None: timestamp = self.timestamp
if self.timestamp_format is not None:
root_name = (time.strftime(self.timestamp_format, timestamp)
+ '-' + self.batch_name)
else:
root_name = self.batch_name
path = os.path.join(self.output_directory,
*(self.subdir+[root_name]))
return os.path.abspath(path)
|
[
"A",
"helper",
"method",
"that",
"supplies",
"the",
"root",
"directory",
"name",
"given",
"a",
"timestamp",
"."
] |
ioam/lancet
|
python
|
https://github.com/ioam/lancet/blob/1fbbf88fa0e8974ff9ed462e3cb11722ddebdd6e/lancet/launch.py#L462-L476
|
[
"def",
"get_root_directory",
"(",
"self",
",",
"timestamp",
"=",
"None",
")",
":",
"if",
"timestamp",
"is",
"None",
":",
"timestamp",
"=",
"self",
".",
"timestamp",
"if",
"self",
".",
"timestamp_format",
"is",
"not",
"None",
":",
"root_name",
"=",
"(",
"time",
".",
"strftime",
"(",
"self",
".",
"timestamp_format",
",",
"timestamp",
")",
"+",
"'-'",
"+",
"self",
".",
"batch_name",
")",
"else",
":",
"root_name",
"=",
"self",
".",
"batch_name",
"path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"output_directory",
",",
"*",
"(",
"self",
".",
"subdir",
"+",
"[",
"root_name",
"]",
")",
")",
"return",
"os",
".",
"path",
".",
"abspath",
"(",
"path",
")"
] |
1fbbf88fa0e8974ff9ed462e3cb11722ddebdd6e
|
valid
|
Launcher._append_log
|
The log contains the tids and corresponding specifications
used during launch with the specifications in JSON format.
|
lancet/launch.py
|
def _append_log(self, specs):
"""
The log contains the tids and corresponding specifications
used during launch with the specifications in JSON format.
"""
self._spec_log += specs # This should be removed
log_path = os.path.join(self.root_directory, ("%s.log" % self.batch_name))
core.Log.write_log(log_path, [spec for (_, spec) in specs], allow_append=True)
|
def _append_log(self, specs):
"""
The log contains the tids and corresponding specifications
used during launch with the specifications in JSON format.
"""
self._spec_log += specs # This should be removed
log_path = os.path.join(self.root_directory, ("%s.log" % self.batch_name))
core.Log.write_log(log_path, [spec for (_, spec) in specs], allow_append=True)
|
[
"The",
"log",
"contains",
"the",
"tids",
"and",
"corresponding",
"specifications",
"used",
"during",
"launch",
"with",
"the",
"specifications",
"in",
"JSON",
"format",
"."
] |
ioam/lancet
|
python
|
https://github.com/ioam/lancet/blob/1fbbf88fa0e8974ff9ed462e3cb11722ddebdd6e/lancet/launch.py#L478-L485
|
[
"def",
"_append_log",
"(",
"self",
",",
"specs",
")",
":",
"self",
".",
"_spec_log",
"+=",
"specs",
"# This should be removed",
"log_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"root_directory",
",",
"(",
"\"%s.log\"",
"%",
"self",
".",
"batch_name",
")",
")",
"core",
".",
"Log",
".",
"write_log",
"(",
"log_path",
",",
"[",
"spec",
"for",
"(",
"_",
",",
"spec",
")",
"in",
"specs",
"]",
",",
"allow_append",
"=",
"True",
")"
] |
1fbbf88fa0e8974ff9ed462e3cb11722ddebdd6e
|
valid
|
Launcher._record_info
|
All launchers should call this method to write the info file
at the end of the launch. The .info file is saved given
setup_info supplied by _setup_launch into the
root_directory. When called without setup_info, the existing
info file is updated with the end-time.
|
lancet/launch.py
|
def _record_info(self, setup_info=None):
"""
All launchers should call this method to write the info file
at the end of the launch. The .info file is saved given
setup_info supplied by _setup_launch into the
root_directory. When called without setup_info, the existing
info file is updated with the end-time.
"""
info_path = os.path.join(self.root_directory, ('%s.info' % self.batch_name))
if setup_info is None:
try:
with open(info_path, 'r') as info_file:
setup_info = json.load(info_file)
except:
setup_info = {}
setup_info.update({'end_time' : tuple(time.localtime())})
else:
setup_info.update({
'end_time' : None,
'metadata' : self.metadata
})
with open(info_path, 'w') as info_file:
json.dump(setup_info, info_file, sort_keys=True, indent=4)
|
def _record_info(self, setup_info=None):
"""
All launchers should call this method to write the info file
at the end of the launch. The .info file is saved given
setup_info supplied by _setup_launch into the
root_directory. When called without setup_info, the existing
info file is updated with the end-time.
"""
info_path = os.path.join(self.root_directory, ('%s.info' % self.batch_name))
if setup_info is None:
try:
with open(info_path, 'r') as info_file:
setup_info = json.load(info_file)
except:
setup_info = {}
setup_info.update({'end_time' : tuple(time.localtime())})
else:
setup_info.update({
'end_time' : None,
'metadata' : self.metadata
})
with open(info_path, 'w') as info_file:
json.dump(setup_info, info_file, sort_keys=True, indent=4)
|
[
"All",
"launchers",
"should",
"call",
"this",
"method",
"to",
"write",
"the",
"info",
"file",
"at",
"the",
"end",
"of",
"the",
"launch",
".",
"The",
".",
"info",
"file",
"is",
"saved",
"given",
"setup_info",
"supplied",
"by",
"_setup_launch",
"into",
"the",
"root_directory",
".",
"When",
"called",
"without",
"setup_info",
"the",
"existing",
"info",
"file",
"is",
"updated",
"with",
"the",
"end",
"-",
"time",
"."
] |
ioam/lancet
|
python
|
https://github.com/ioam/lancet/blob/1fbbf88fa0e8974ff9ed462e3cb11722ddebdd6e/lancet/launch.py#L487-L512
|
[
"def",
"_record_info",
"(",
"self",
",",
"setup_info",
"=",
"None",
")",
":",
"info_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"root_directory",
",",
"(",
"'%s.info'",
"%",
"self",
".",
"batch_name",
")",
")",
"if",
"setup_info",
"is",
"None",
":",
"try",
":",
"with",
"open",
"(",
"info_path",
",",
"'r'",
")",
"as",
"info_file",
":",
"setup_info",
"=",
"json",
".",
"load",
"(",
"info_file",
")",
"except",
":",
"setup_info",
"=",
"{",
"}",
"setup_info",
".",
"update",
"(",
"{",
"'end_time'",
":",
"tuple",
"(",
"time",
".",
"localtime",
"(",
")",
")",
"}",
")",
"else",
":",
"setup_info",
".",
"update",
"(",
"{",
"'end_time'",
":",
"None",
",",
"'metadata'",
":",
"self",
".",
"metadata",
"}",
")",
"with",
"open",
"(",
"info_path",
",",
"'w'",
")",
"as",
"info_file",
":",
"json",
".",
"dump",
"(",
"setup_info",
",",
"info_file",
",",
"sort_keys",
"=",
"True",
",",
"indent",
"=",
"4",
")"
] |
1fbbf88fa0e8974ff9ed462e3cb11722ddebdd6e
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.