func _main(c *cli.Context) {
gShowKnotNocallInfoFlag = !c.Bool("hide-knot-low-quality")
inp_slice := c.StringSlice("input")
cglf_lib_location := c.String("cglf")
action := c.String("action")
if action == "debug" {
//debug_read(c.String("cgf"))
cgf.DebugRead(c.String("cgf"))
return
} else if action == "headercheck" {
//header_bytes := cgf_default_header_bytes()
header_bytes := cgf.CGFDefaultHeaderBytes()
//hdri,dn := headerintermediate_from_bytes(header_bytes) ; _ = dn
hdri, dn := cgf.HeaderIntermediateFromBytes(header_bytes)
_ = dn
//hdri_bytes := bytes_from_headerintermediate(hdri)
hdri_bytes := cgf.BytesFromHeaderIntermediate(hdri)
//hdri1,dn2 := headerintermediate_from_bytes(hdri_bytes) ; _ = dn2
hdri1, dn2 := cgf.HeaderIntermediateFromBytes(hdri_bytes)
_ = dn2
//err := headerintermediate_cmp(hdri, hdri1)
err := cgf.HeaderIntermediateCmp(hdri, hdri1)
if err != nil {
log.Fatal(err)
}
return
} else if action == "header" {
ocgf := c.String("output")
//header_bytes := cgf_default_header_bytes()
header_bytes := cgf.CGFDefaultHeaderBytes()
f, err := os.Create(ocgf)
if err != nil {
log.Fatal(err)
}
f.Write(header_bytes)
f.Sync()
f.Close()
return
} else if action == "knot" {
cglf_path := c.String("cglf")
if len(cglf_path) == 0 {
fmt.Fprintf(os.Stderr, "Provide CGLF\n")
cli.ShowAppHelp(c)
os.Exit(1)
}
cgf_bytes, e := ioutil.ReadFile(c.String("cgf"))
if e != nil {
log.Fatal(e)
}
//hdri,dn := headerintermediate_from_bytes(cgf_bytes[:])
hdri, dn := cgf.HeaderIntermediateFromBytes(cgf_bytes[:])
_ = hdri
_ = dn
//path,ver,step,e := parse_tilepos(c.String("tilepos"))
path, ver, step, e := cgf.ParseTilepos(c.String("tilepos"))
if e != nil {
log.Fatal(e)
}
if path < 0 {
log.Fatal("path must be positive")
}
if step < 0 {
log.Fatal("step must be positive")
}
//if path >= len(hdri.step_per_path) { log.Fatal("path out of range (max ", len(hdri.step_per_path), " paths)") }
//if step>= hdri.step_per_path[path] { log.Fatal("step out of range (max ", hdri.step_per_path[path], " steps)") }
if path >= len(hdri.StepPerPath) {
log.Fatal("path out of range (max ", len(hdri.StepPerPath), " paths)")
}
if step >= hdri.StepPerPath[path] {
log.Fatal("step out of range (max ", hdri.StepPerPath[path], " steps)")
}
//pathi,_ := pathintermediate_from_bytes(hdri.path_bytes[path])
pathi, _ := cgf.PathIntermediateFromBytes(hdri.PathBytes[path])
knot := cgf.GetKnot(hdri.TileMap, pathi, step)
if knot == nil {
fmt.Printf("spanning tile?\n")
} else {
for i := 0; i < len(knot); i++ {
phase_str := "A"
if i == 1 {
phase_str = "B"
}
for j := 0; j < len(knot[i]); j++ {
fmt.Printf("%s %04x.%02x.%04x.%03x+%x",
phase_str,
path, ver,
knot[i][j].Step,
knot[i][j].VarId,
knot[i][j].Span)
seq := cgf.CGLFGetLibSeq(uint64(path),
uint64(knot[i][j].Step),
uint64(knot[i][j].VarId),
uint64(knot[i][j].Span),
cglf_path)
if len(knot[i][j].NocallStartLen) > 0 {
fmt.Printf("*{")
for p := 0; p < len(knot[i][j].NocallStartLen); p += 2 {
if p > 0 {
fmt.Printf(";")
}
fmt.Printf("%d+%d",
knot[i][j].NocallStartLen[p],
knot[i][j].NocallStartLen[p+1])
}
fmt.Printf("}")
//noc_seq := fill_noc_seq(seq, knot[i][j].NocallStartLen)
noc_seq := cgf.FillNocSeq(seq, knot[i][j].NocallStartLen)
noc_m5str := cgf.Md5sum2str(md5.Sum([]byte(noc_seq)))
fmt.Printf(" %s\n%s\n", noc_m5str, noc_seq)
} else {
m5str := cgf.Md5sum2str(md5.Sum([]byte(seq)))
fmt.Printf(" %s\n%s\n", m5str, seq)
}
}
}
}
return
} else if action == "fastj" {
tilepos_str := c.String("tilepos")
if len(tilepos_str) == 0 {
log.Fatal("missing tilepos")
}
if use_SGLF {
_sglf, e := cglf.LoadGenomeLibraryCSV(c.String("sglf"))
if e != nil {
log.Fatal(e)
}
for i := 0; i < len(inp_slice); i++ {
//e = print_tile_sglf(inp_slice[i], tilepos_str, sglf)
e = cgf.PrintTileSGLF(inp_slice[i], tilepos_str, _sglf)
if e != nil {
log.Fatal(e)
}
}
} else {
if len(c.String("cgf")) != 0 {
inp_slice = append(inp_slice, c.String("cgf"))
}
for i := 0; i < len(inp_slice); i++ {
//e := print_tile_cglf(inp_slice[i], tilepos_str, cglf_lib_location)
e := cgf.PrintTileCGLF(inp_slice[i], tilepos_str, cglf_lib_location)
if e != nil {
log.Fatal(e)
}
}
}
return
} else if action == "fastj-range" {
tilepos_str := c.String("tilepos")
pos_parts := strings.Split(tilepos_str, ".")
if (len(pos_parts) != 2) && (len(pos_parts) != 3) {
fmt.Fprintf(os.Stderr, "Invalid tilepos\n")
cli.ShowAppHelp(c)
os.Exit(1)
}
path_range, e := parseIntOption(pos_parts[0], 16)
if e != nil {
fmt.Fprintf(os.Stderr, "Invalid path in tilepos: %v\n", e)
cli.ShowAppHelp(c)
os.Exit(1)
}
pp := 1
if len(pos_parts) == 3 {
pp = 2
}
step_range, e := parseIntOption(pos_parts[pp], 16)
if e != nil {
fmt.Fprintf(os.Stderr, "Invalid step in tilepos: %v\n", e)
cli.ShowAppHelp(c)
os.Exit(1)
}
if len(tilepos_str) == 0 {
log.Fatal("missing tilepos")
}
if len(c.String("sglf")) > 0 {
use_SGLF = true
}
if use_SGLF {
_sglf, e := cglf.LoadGenomeLibraryCSV(c.String("sglf"))
_ = _sglf
if e != nil {
log.Fatal(e)
}
if len(c.String("cgf")) != 0 {
inp_slice = append(inp_slice, c.String("cgf"))
}
for i := 0; i < len(inp_slice); i++ {
cgf_bytes, e := ioutil.ReadFile(inp_slice[i])
if e != nil {
log.Fatal(e)
}
path := path_range[0][0]
//hdri,_ := headerintermediate_from_bytes(cgf_bytes) ; _ = hdri
//pathi,_ := pathintermediate_from_bytes(hdri.PathBytes[path]) ; _ = pathi
hdri, _ := cgf.HeaderIntermediateFromBytes(cgf_bytes)
_ = hdri
pathi, _ := cgf.PathIntermediateFromBytes(hdri.PathBytes[path])
_ = pathi
//hdri,dn := headerintermediate_from_bytes(cgf_bytes)
hdri, dn := cgf.HeaderIntermediateFromBytes(cgf_bytes)
if dn < 0 {
log.Fatal("could not construct header from bytes")
}
//patho,dn := pathintermediate_from_bytes(hdri.PathBytes[path])
patho, dn := cgf.PathIntermediateFromBytes(hdri.PathBytes[path])
if dn < 0 {
log.Fatal("could not construct path")
}
tilemap_bytes, _ := cgf.CGFTilemapBytes(cgf_bytes)
//tilemap := unpack_tilemap(tilemap_bytes)
tilemap := cgf.UnpackTileMap(tilemap_bytes)
for step_idx := 0; step_idx < len(step_range); step_idx++ {
if step_range[step_idx][1] == -1 {
//step_range[step_idx][1] = int64(hdri.step_per_path[path])
step_range[step_idx][1] = int64(hdri.StepPerPath[path])
}
}
for stepr_idx := 0; stepr_idx < len(step_range); stepr_idx++ {
for step := step_range[stepr_idx][0]; step < step_range[stepr_idx][1]; step++ {
//knot := GetKnot(tilemap, patho, int(step))
//print_knot_fastj_sglf(knot, _sglf, uint64(path), 0, hdri)
knot := cgf.GetKnot(tilemap, patho, int(step))
cgf.PrintKnotFastjSGLF(knot, _sglf, uint64(path), 0, hdri)
}
}
}
return
} else {
if len(c.String("cgf")) != 0 {
inp_slice = append(inp_slice, c.String("cgf"))
}
for i := 0; i < len(inp_slice); i++ {
cgf_bytes, e := ioutil.ReadFile(inp_slice[i])
if e != nil {
log.Fatal(e)
}
path := path_range[0][0]
_sglf := cglf.SGLF{}
//populate_sglf_from_cglf(c.String("cglf"), &_sglf, uint64(path))
cgf.PopulateSGLFFromCGLF(c.String("cglf"), &_sglf, uint64(path))
os.Exit(0)
//hdri,_ := headerintermediate_from_bytes(cgf_bytes) ; _ = hdri
//pathi,_ := pathintermediate_from_bytes(hdri.PathBytes[path]) ; _ = pathi
hdri, _ := cgf.HeaderIntermediateFromBytes(cgf_bytes)
_ = hdri
pathi, _ := cgf.PathIntermediateFromBytes(hdri.PathBytes[path])
_ = pathi
//hdri,dn := headerintermediate_from_bytes(cgf_bytes)
hdri, dn := cgf.HeaderIntermediateFromBytes(cgf_bytes)
if dn < 0 {
log.Fatal("could not construct header from bytes")
}
//patho,dn := pathintermediate_from_bytes(hdri.PathBytes[path])
patho, dn := cgf.PathIntermediateFromBytes(hdri.PathBytes[path])
if dn < 0 {
log.Fatal("could not construct path")
}
tilemap_bytes, _ := cgf.CGFTilemapBytes(cgf_bytes)
//tilemap := unpack_tilemap(tilemap_bytes)
tilemap := cgf.UnpackTileMap(tilemap_bytes)
for step_idx := 0; step_idx < len(step_range); step_idx++ {
if step_range[step_idx][1] == -1 {
//step_range[step_idx][1] = int64(hdri.step_per_path[path])
step_range[step_idx][1] = int64(hdri.StepPerPath[path])
}
}
for stepr_idx := 0; stepr_idx < len(step_range); stepr_idx++ {
for step := step_range[stepr_idx][0]; step < step_range[stepr_idx][1]; step++ {
//knot := GetKnot(tilemap, patho, int(step))
//print_knot_fastj_sglf(knot, _sglf, uint64(path), 0, hdri)
knot := cgf.GetKnot(tilemap, patho, int(step))
cgf.PrintKnotFastjSGLF(knot, _sglf, uint64(path), 0, hdri)
}
}
}
}
return
} else if action == "knot-z" {
cgf_bytes, e := ioutil.ReadFile(c.String("cgf"))
_ = cgf_bytes
if e != nil {
log.Fatal(e)
}
path, ver, step, e := cgf.ParseTilepos(c.String("tilepos"))
_ = path
_ = ver
_ = step
if e != nil {
log.Fatal(e)
}
if path < 0 {
log.Fatal("path must be positive")
}
if step < 0 {
log.Fatal("step must be positive")
}
fmt.Printf("not implemented\n")
return
} else if action == "knot-2" {
cgf_bytes, e := ioutil.ReadFile(c.String("cgf"))
if e != nil {
log.Fatal(e)
}
//hdri,dn := headerintermediate_from_bytes(cgf_bytes[:])
hdri, dn := cgf.HeaderIntermediateFromBytes(cgf_bytes[:])
_ = hdri
_ = dn
//path,ver,step,e := parse_tilepos(c.String("tilepos"))
path, ver, step, e := cgf.ParseTilepos(c.String("tilepos"))
if e != nil {
log.Fatal(e)
}
if path < 0 {
log.Fatal("path must be positive")
}
if step < 0 {
log.Fatal("step must be positive")
}
//if path >= len(hdri.step_per_path) { log.Fatal("path out of range (max ", len(hdri.step_per_path), " paths)") }
//if step>= hdri.step_per_path[path] { log.Fatal("step out of range (max ", hdri.step_per_path[path], " steps)") }
if path >= len(hdri.StepPerPath) {
log.Fatal("path out of range (max ", len(hdri.StepPerPath), " paths)")
}
if step >= hdri.StepPerPath[path] {
log.Fatal("step out of range (max ", hdri.StepPerPath[path], " steps)")
}
//pathi,_ := pathintermediate_from_bytes(hdri.PathBytes[path])
pathi, _ := cgf.PathIntermediateFromBytes(hdri.PathBytes[path])
//knot := GetKnot(hdri.tilemap, pathi, step)
knot := cgf.GetKnot(hdri.TileMap, pathi, step)
if knot == nil {
fmt.Printf("spanning tile?")
} else {
for i := 0; i < len(knot); i++ {
for j := 0; j < len(knot[i]); j++ {
if j > 0 {
fmt.Printf(" ")
}
fmt.Printf("%04x.%02x.%04x.%03x+%x",
path, ver,
knot[i][j].Step,
knot[i][j].VarId,
knot[i][j].Span)
if gShowKnotNocallInfoFlag {
if len(knot[i][j].NocallStartLen) > 0 {
fmt.Printf("*{")
for p := 0; p < len(knot[i][j].NocallStartLen); p += 2 {
if p > 0 {
fmt.Printf(";")
}
fmt.Printf("%d+%d",
knot[i][j].NocallStartLen[p],
knot[i][j].NocallStartLen[p+1])
}
fmt.Printf("}")
}
}
}
fmt.Printf("\n")
}
}
return
} else if action == "sglfbarf" {
//_sglf,e := LoadGenomeLibraryCSV(c.String("sglf"))
_sglf, e := cglf.LoadGenomeLibraryCSV(c.String("sglf"))
if e != nil {
log.Fatal(e)
}
for path := range _sglf.LibInfo {
for step := range _sglf.LibInfo[path] {
for i := 0; i < len(_sglf.LibInfo[path][step]); i++ {
fmt.Printf("%x,%x,%x.%x.%x+%x\n", path, step,
_sglf.LibInfo[path][step][i].Path,
_sglf.LibInfo[path][step][i].Step,
_sglf.LibInfo[path][step][i].Variant,
_sglf.LibInfo[path][step][i].Span)
}
}
}
return
} else if action == "append" {
_sglf, e := cglf.LoadGenomeLibraryCSV(c.String("sglf"))
if e != nil {
log.Fatal(e)
}
ain_slice := make([]autoio.AutoioHandle, 0, 8)
for i := 0; i < len(inp_slice); i++ {
inp_fn := inp_slice[i]
ain, err := autoio.OpenReadScanner(inp_fn)
_ = ain
if err != nil {
fmt.Fprintf(os.Stderr, "%v", err)
os.Exit(1)
}
defer ain.Close()
ain_slice = append(ain_slice, ain)
break
}
path_str := c.String("path")
path_u64, e := strconv.ParseInt(path_str, 16, 64)
if e != nil {
log.Fatal(e)
}
path := int(path_u64)
cgf_bytes, e := ioutil.ReadFile(c.String("cgf"))
if e != nil {
log.Fatal(e)
}
//hdri,_ := headerintermediate_from_bytes(cgf_bytes[:])
hdri, _ := cgf.HeaderIntermediateFromBytes(cgf_bytes[:])
ctx := cgf.CGFContext{}
_cgf := cgf.CGF{}
_cgf.PathBytes = make([][]byte, 0, 1024)
cgf.CGFFillHeader(&_cgf, cgf_bytes)
ctx.CGF = &_cgf
ctx.SGLF = &_sglf
//CGFContext_construct_tilemap_lookup(&ctx)
ctx.ConstructTileMapLookup()
//allele_path,e := load_sample_fastj(&ain_slice[0])
allele_path, e := cgf.LoadSampleFastj(&ain_slice[0])
if e != nil {
log.Fatal(e)
}
//PathBytes,e := emit_path_bytes(&ctx, path, allele_path)
PathBytes, e := ctx.EmitPathBytes(path, allele_path)
if e != nil {
log.Fatal(e)
}
//headerintermediate_add_path(&hdri, path, PathBytes)
//write_cgf_from_intermediate(c.String("output"), &hdri)
cgf.HeaderIntermediateAddPath(&hdri, path, PathBytes)
cgf.WriteCGFFromIntermediate(c.String("output"), &hdri)
return
}
ain_slice := make([]autoio.AutoioHandle, 0, 8)
for i := 0; i < len(inp_slice); i++ {
inp_fn := inp_slice[i]
ain, err := autoio.OpenReadScanner(inp_fn)
_ = ain
if err != nil {
fmt.Fprintf(os.Stderr, "%v", err)
os.Exit(1)
}
defer ain.Close()
ain_slice = append(ain_slice, ain)
}
aout, err := autoio.CreateWriter(c.String("output"))
_ = aout
if err != nil {
fmt.Fprintf(os.Stderr, "%v", err)
os.Exit(1)
}
defer func() { aout.Flush(); aout.Close() }()
if c.Bool("pprof") {
gProfileFlag = true
gProfileFile = c.String("pprof-file")
}
if c.Bool("mprof") {
gMemProfileFlag = true
gMemProfileFile = c.String("mprof-file")
}
gVerboseFlag = c.Bool("Verbose")
if c.Int("max-procs") > 0 {
runtime.GOMAXPROCS(c.Int("max-procs"))
}
if gProfileFlag {
prof_f, err := os.Create(gProfileFile)
if err != nil {
fmt.Fprintf(os.Stderr, "Could not open profile file %s: %v\n", gProfileFile, err)
os.Exit(2)
}
pprof.StartCPUProfile(prof_f)
defer pprof.StopCPUProfile()
}
_sglf, e := cglf.LoadGenomeLibraryCSV(c.String("sglf"))
if e != nil {
log.Fatal(e)
}
ctx := cgf.CGFContext{}
_cgf := cgf.CGF{}
//header_bytes := cgf_default_header_bytes()
header_bytes := cgf.CGFDefaultHeaderBytes()
cgf.CGFFillHeader(&_cgf, header_bytes)
ctx.CGF = &_cgf
ctx.SGLF = &_sglf
//CGFContext_construct_tilemap_lookup(&ctx)
ctx.ConstructTileMapLookup()
for i := 0; i < len(ain_slice); i++ {
ain := ain_slice[i]
//allele_path,e := load_sample_fastj(&ain)
allele_path, e := cgf.LoadSampleFastj(&ain)
if e != nil {
log.Fatal(e)
}
p := 0x2c5
if i > 0 {
p = 0x247
}
//e = update_vector_path_simple(&ctx, p, allele_path)
e = ctx.UpdateVectorPathSimple(p, allele_path)
if len(ctx.CGF.StepPerPath) < len(ain_slice) {
ctx.CGF.StepPerPath = append(ctx.CGF.StepPerPath, uint64(len(_sglf.Lib[p])))
}
}
ctx.CGF.PathCount = uint64(len(_cgf.Path))
ctx.CGF.StepPerPath = make([]uint64, ctx.CGF.PathCount)
for i := uint64(0); i < ctx.CGF.PathCount; i++ {
ctx.CGF.StepPerPath[i] = uint64(len(_sglf.Lib[int(i)]))
}
//write_cgf(&ctx, "out.cgf")
ctx.WriteCGF("out.cgf")
}
func (ctx *LanternContext) APITileLibraryTagSetsIdTilePositionsId(w http.ResponseWriter, r *http.Request, param httprouter.Params) {
tagset_id := param.ByName("tagset_id")
tilepos := param.ByName("tilepos_id")
if _, ok := ctx.Config.O["tagset"].O[tagset_id]; !ok {
send_error_bad_request(w, "invalid tagset id")
return
}
if len(tilepos) == 0 {
send_error_bad_request(w, "invalid tilepos")
return
}
tile_parts := strings.Split(tilepos, ".")
if len(tile_parts) != 3 {
send_error_bad_request(w, "invalid tilepos")
return
}
_req_tagset_name, e := strconv.ParseInt(tile_parts[0], 16, 64)
if e != nil {
send_error_bad_request(w, "invalid tagset id")
return
}
_req_path, e := strconv.ParseInt(tile_parts[1], 16, 64)
if e != nil {
send_error_bad_request(w, "invalid path id")
return
}
_req_step, e := strconv.ParseInt(tile_parts[2], 16, 64)
if e != nil {
send_error_bad_request(w, "invalid step id")
return
}
if ctx.VerboseFlag {
log.Printf("APITileLibraryTagSetsIdTilePositionsId %v\n", tagset_id)
}
req_tagset_name := int(_req_tagset_name)
_ = req_tagset_name
req_path := int(_req_path)
req_step := int(_req_step)
if req_path < 0 || req_path >= len(ctx.Config.O["tagset"].O[tagset_id].O["step_per_path"].L) {
send_error_bad_request(w, "path out of range")
return
}
if req_step < 0 || req_step >= int(ctx.Config.O["tagset"].O[tagset_id].O["step_per_path"].L[req_path].P+0.5) {
send_error_bad_request(w, "step out of range")
return
}
tagset_name := int(ctx.Config.O["tagset"].O[tagset_id].O["id"].P + 0.5)
tilepos_str := fmt.Sprintf("%02x.%04x.%04x", tagset_name, req_path, req_step)
//TODO: get this information
// this is a placeholder for now
//n_tile_var:=-1
//n_hiq_tile_var:=-1
n_genomes := len(ctx.CGFBytes)
// SLOW AND MEMORY INTENSIVE
//
n_sample := len(ctx.CGFPath)
if req_path >= len(ctx.CGFPath[0]) {
send_error_bad_request(w, "step out of range")
return
}
//tcount := make([]int, n_sample)
tmap := make(map[string]bool)
loq_tmap := make(map[string]bool)
for sample := 0; sample < n_sample; sample++ {
knot := cgf.GetKnot(ctx.TileMap, ctx.CGFPath[sample][req_path], req_step)
for i := 0; i < len(knot); i++ {
for j := 0; j < len(knot[i]); j++ {
s := fmt.Sprintf("%04x.%02x.%04x.%03x+%x", req_path, 0, knot[i][j].Step, knot[i][j].VarId, knot[i][j].Span)
if len(knot[i][j].NocallStartLen) == 0 {
tmap[s] = true
} else {
loq_tmap[s] = true
}
}
}
}
io.WriteString(w, `{`)
io.WriteString(w, fmt.Sprintf(`"tile-position":"%s"`, tilepos_str))
io.WriteString(w, fmt.Sprintf(`,"total-tile-variants":%d`, len(tmap)+len(loq_tmap)))
io.WriteString(w, fmt.Sprintf(`,"well-sequenced-tile-variants":%d`, len(tmap)))
io.WriteString(w, fmt.Sprintf(`,"num-genomes":%d`, n_genomes))
io.WriteString(w, `}`)
}
func (ctx *LanternContext) APITileLibraryTagSetsIdTileVariantsId(w http.ResponseWriter, r *http.Request, param httprouter.Params) {
tagset_id := param.ByName("tagset_id")
tilevariant_id := param.ByName("tilevariant_id")
if _, ok := ctx.Config.O["tagset"].O[tagset_id]; !ok {
send_error_bad_request(w, "invalid tagset id")
return
}
if len(tilevariant_id) == 0 {
send_error_bad_request(w, "invalid tilevariant id")
return
}
tile_parts := strings.Split(tilevariant_id, ".")
if len(tile_parts) != 4 {
send_error_bad_request(w, "invalid tilepos")
return
}
_req_tagset_name, e := strconv.ParseInt(tile_parts[0], 16, 64)
if e != nil {
send_error_bad_request(w, "invalid tagset id")
return
}
_req_path, e := strconv.ParseInt(tile_parts[1], 16, 64)
if e != nil {
send_error_bad_request(w, "invalid path id")
return
}
_req_step, e := strconv.ParseInt(tile_parts[2], 16, 64)
if e != nil {
send_error_bad_request(w, "invalid step id")
return
}
req_tagset_name := int(_req_tagset_name)
req_path := int(_req_path)
req_step := int(_req_step)
req_md5sum := tile_parts[3]
if ctx.VerboseFlag {
log.Printf("APITileLibraryTagSetsIdTileVariantsId %v, tilevariant_id %v, tagset %d, path %d, step %d, md5sum %s\n",
tagset_id, tilevariant_id, req_tagset_name, req_path, req_step, req_md5sum)
}
if req_path < 0 || req_path >= len(ctx.Config.O["tagset"].O[tagset_id].O["step_per_path"].L) {
send_error_bad_request(w, "path out of range")
return
}
if req_step < 0 || req_step >= int(ctx.Config.O["tagset"].O[tagset_id].O["step_per_path"].L[req_path].P+0.5) {
send_error_bad_request(w, "step out of range")
return
}
sglf_info, ok := ctx.SGLF.MD5Lookup[req_md5sum]
_ = sglf_info
if !ok {
send_error_bad_request(w, "invalid md5sum")
return
}
rank := sglf_info.Variant
seq := ctx.SGLF.Lib[req_path][req_step][rank]
first_tile := "false"
last_tile := "false"
n := len(seq)
pfx := seq[0:24]
sfx := seq[n-24:]
if req_step == 0 {
first_tile = "true"
pfx = ""
}
if req_step == 999999 {
last_tile = "true"
sfx = ""
}
het_count := 0
hom_count := 0
haplotype_count := 0
count := 0
n_sample := len(ctx.CGFPath)
for sample := 0; sample < n_sample; sample++ {
knot := cgf.GetKnot(ctx.TileMap, ctx.CGFPath[sample][req_path], req_step)
allele_found_count := 0
for i := 0; i < len(knot); i++ {
cur_step := req_step
for j := 0; j < len(knot[i]); j++ {
if cur_step < req_step {
cur_step += knot[i][j].Step
continue
}
if cur_step > req_step {
break
}
if knot[i][j].VarId == rank {
allele_found_count++
}
break
}
}
if allele_found_count > 0 {
count++
}
if allele_found_count == 1 {
het_count++
} else {
hom_count++
}
haplotype_count += allele_found_count
}
ratio := float64(count) / float64(n_sample)
io.WriteString(w, `{`)
io.WriteString(w, fmt.Sprintf(`"tile-variant":"%02x.%04x.%04x.%s",`, req_tagset_name, req_path, req_step, req_md5sum))
io.WriteString(w, fmt.Sprintf(`"tag-length":24,`))
io.WriteString(w, fmt.Sprintf(`"start-tag":"%s",`, pfx))
io.WriteString(w, fmt.Sprintf(`"end-tag":"%s",`, sfx))
io.WriteString(w, fmt.Sprintf(`"is-start-of-path":%s,`, first_tile))
io.WriteString(w, fmt.Sprintf(`"is-end-of-path":%s,`, last_tile))
io.WriteString(w, fmt.Sprintf(`"sequence":"%s",`, seq))
io.WriteString(w, fmt.Sprintf(`"md5sum":"%s",`, req_md5sum))
io.WriteString(w, fmt.Sprintf(`"length":%d,`, len(seq)))
io.WriteString(w, fmt.Sprintf(`"number-of-positions-spanned":%d,`, sglf_info.Span))
io.WriteString(w, fmt.Sprintf(`"populateion-frequency":%f,`, ratio))
io.WriteString(w, fmt.Sprintf(`"homozygous-count":%d,`, hom_count))
io.WriteString(w, fmt.Sprintf(`"heterozygous-count":%d,`, het_count))
io.WriteString(w, fmt.Sprintf(`"haplotype-count":%d,`, haplotype_count))
io.WriteString(w, fmt.Sprintf(`"population-count":%d,`, count))
io.WriteString(w, fmt.Sprintf(`"population-total":%d`, n_sample))
io.WriteString(w, `}`)
//tagset_name := int(ctx.Config.O["tagset"].O[tagset_id].O["id"].P+0.5)
//tilepos_str := fmt.Sprintf("%02x.%04x.%04x", tagset_name, req_path, req_step)
}
func (ctx *LanternContext) APICallsetsIdTileVariants(w http.ResponseWriter, r *http.Request, param httprouter.Params) {
callset_name := param.ByName("callset_id")
tilepos := r.FormValue("tile-positions")
if ctx.VerboseFlag {
log.Printf("APICallsetsIdTileVariants callset_id %v, tile-positions %v\n", callset_name, tilepos)
}
if _, ok := ctx.CGFIndexMap[callset_name]; !ok {
send_error_bad_request(w, "invalid tagset id")
return
}
tile_parts := strings.Split(tilepos, ".")
if len(tile_parts) != 3 {
send_error_bad_request(w, "invalid tilepos")
return
}
_req_tagset, e := strconv.ParseInt(tile_parts[0], 16, 64)
if e != nil {
send_error_bad_request(w, "invalid tagset id")
return
}
_req_path, e := strconv.ParseInt(tile_parts[1], 16, 64)
if e != nil {
send_error_bad_request(w, "invalid path id")
return
}
_req_step, e := strconv.ParseInt(tile_parts[2], 16, 64)
if e != nil {
send_error_bad_request(w, "invalid step id")
return
}
req_tagset := int(_req_tagset)
_ = req_tagset
req_path := int(_req_path)
_ = req_path
req_step := int(_req_step)
_ = req_step
callset_idx := ctx.CGFIndexMap[callset_name]
knot := cgf.GetKnot(ctx.TileMap, ctx.CGFPath[callset_idx][req_path], req_step)
io.WriteString(w, `{`)
io.WriteString(w, `"callset-name":"`+callset_name+`",`)
io.WriteString(w, `"tile-variants":[`)
count := 0
for a := 0; a < len(knot); a++ {
cur_step := knot[a][0].Step
if a > 0 {
io.WriteString(w, `,[`)
} else {
io.WriteString(w, `[`)
}
for i := 0; i < len(knot[a]); i++ {
varid := knot[a][i].VarId
_seq := ctx.SGLF.Lib[req_path][cur_step][varid]
seq := cgf.FillNocSeq(_seq, knot[a][i].NocallStartLen)
m5str := cgf.Md5sum2str(md5.Sum([]byte(seq)))
loq_flag := ""
if len(knot[a][i].NocallStartLen) > 0 {
loq_flag = "*"
}
tilestr := fmt.Sprintf("%02x.%04x.%04x.%s+%x%s",
req_tagset, req_path, cur_step, m5str, knot[a][i].Span, loq_flag)
if i > 0 {
io.WriteString(w, `,`)
}
io.WriteString(w, `"`+tilestr+`"`)
cur_step += knot[a][i].Span
count++
}
io.WriteString(w, `]`)
}
io.WriteString(w, `]`)
io.WriteString(w, `}`)
}