+
+// Read case/control files, remove non-case/control entries from
+// cmd.cgnames, and build cmd.chi2Cases.
+func (cmd *sliceNumpy) useCaseControlFiles() error {
+ if cmd.chi2CaseControlFile == "" {
+ return nil
+ }
+ infiles, err := allFiles(cmd.chi2CaseControlFile, nil)
+ if err != nil {
+ return err
+ }
+ // index in cmd.cgnames => case(true) / control(false)
+ cc := map[int]bool{}
+ for _, infile := range infiles {
+ f, err := open(infile)
+ if err != nil {
+ return err
+ }
+ buf, err := io.ReadAll(f)
+ f.Close()
+ if err != nil {
+ return err
+ }
+ ccCol := -1
+ for _, tsv := range bytes.Split(buf, []byte{'\n'}) {
+ if len(tsv) == 0 {
+ continue
+ }
+ split := strings.Split(string(tsv), "\t")
+ if ccCol < 0 {
+ // header row
+ for col, name := range split {
+ if name == cmd.chi2CaseControlColumn {
+ ccCol = col
+ break
+ }
+ }
+ if ccCol < 0 {
+ return fmt.Errorf("%s: no column named %q in header row %q", infile, cmd.chi2CaseControlColumn, tsv)
+ }
+ continue
+ }
+ if len(split) <= ccCol {
+ continue
+ }
+ pattern := split[0]
+ found := -1
+ for i, name := range cmd.cgnames {
+ if strings.Contains(name, pattern) {
+ if found >= 0 {
+ log.Warnf("pattern %q in %s matches multiple genome IDs (%qs, %q)", pattern, infile, cmd.cgnames[found], name)
+ }
+ found = i
+ }
+ }
+ if found < 0 {
+ log.Warnf("pattern %q in %s does not match any genome IDs", pattern, infile)
+ continue
+ }
+ if split[ccCol] == "0" {
+ cc[found] = false
+ }
+ if split[ccCol] == "1" {
+ cc[found] = true
+ }
+ }
+ }
+ allnames := cmd.cgnames
+ cmd.cgnames = nil
+ cmd.chi2Cases = nil
+ ncases := 0
+ for i, name := range allnames {
+ if cc, ok := cc[i]; ok {
+ cmd.cgnames = append(cmd.cgnames, name)
+ cmd.chi2Cases = append(cmd.chi2Cases, cc)
+ if cc {
+ ncases++
+ }
+ }
+ }
+ log.Printf("%d cases, %d controls, %d neither (dropped)", ncases, len(cmd.cgnames)-ncases, len(allnames)-len(cmd.cgnames))
+ return nil
+}
+
+func (cmd *sliceNumpy) filterHGVScolpair(colpair [2][]int8) bool {
+ if cmd.chi2PValue >= 1 {
+ return true
+ }
+ col0 := make([]bool, 0, len(cmd.chi2Cases))
+ col1 := make([]bool, 0, len(cmd.chi2Cases))
+ cases := make([]bool, 0, len(cmd.chi2Cases))
+ for i, c := range cmd.chi2Cases {
+ if colpair[0][i] < 0 {
+ continue
+ }
+ col0 = append(col0, colpair[0][i] != 0)
+ col1 = append(col1, colpair[1][i] != 0)
+ cases = append(cases, c)
+ }
+ return len(cases) >= cmd.minCoverage &&
+ (pvalue(col0, cases) <= cmd.chi2PValue || pvalue(col1, cases) <= cmd.chi2PValue)
+}
+
+func writeNumpyUint32(fnm string, out []uint32, rows, cols int) error {
+ output, err := os.Create(fnm)
+ if err != nil {
+ return err
+ }
+ defer output.Close()
+ bufw := bufio.NewWriterSize(output, 1<<26)
+ npw, err := gonpy.NewWriter(nopCloser{bufw})
+ if err != nil {
+ return err
+ }
+ log.WithFields(log.Fields{
+ "filename": fnm,
+ "rows": rows,
+ "cols": cols,
+ "bytes": rows * cols * 4,
+ }).Infof("writing numpy: %s", fnm)
+ npw.Shape = []int{rows, cols}
+ npw.WriteUint32(out)
+ err = bufw.Flush()
+ if err != nil {
+ return err
+ }
+ return output.Close()
+}
+
+func writeNumpyInt32(fnm string, out []int32, rows, cols int) error {
+ output, err := os.Create(fnm)
+ if err != nil {
+ return err
+ }
+ defer output.Close()
+ bufw := bufio.NewWriterSize(output, 1<<26)
+ npw, err := gonpy.NewWriter(nopCloser{bufw})
+ if err != nil {
+ return err
+ }
+ log.WithFields(log.Fields{
+ "filename": fnm,
+ "rows": rows,
+ "cols": cols,
+ "bytes": rows * cols * 4,
+ }).Infof("writing numpy: %s", fnm)
+ npw.Shape = []int{rows, cols}
+ npw.WriteInt32(out)
+ err = bufw.Flush()
+ if err != nil {
+ return err
+ }
+ return output.Close()
+}
+
+func writeNumpyInt16(fnm string, out []int16, rows, cols int) error {
+ output, err := os.Create(fnm)
+ if err != nil {
+ return err
+ }
+ defer output.Close()
+ bufw := bufio.NewWriterSize(output, 1<<26)
+ npw, err := gonpy.NewWriter(nopCloser{bufw})
+ if err != nil {
+ return err
+ }
+ log.WithFields(log.Fields{
+ "filename": fnm,
+ "rows": rows,
+ "cols": cols,
+ "bytes": rows * cols * 2,
+ }).Infof("writing numpy: %s", fnm)
+ npw.Shape = []int{rows, cols}
+ npw.WriteInt16(out)
+ err = bufw.Flush()
+ if err != nil {
+ return err
+ }
+ return output.Close()
+}
+
+func writeNumpyInt8(fnm string, out []int8, rows, cols int) error {
+ output, err := os.Create(fnm)
+ if err != nil {
+ return err
+ }
+ defer output.Close()
+ bufw := bufio.NewWriterSize(output, 1<<26)
+ npw, err := gonpy.NewWriter(nopCloser{bufw})
+ if err != nil {
+ return err
+ }
+ log.WithFields(log.Fields{
+ "filename": fnm,
+ "rows": rows,
+ "cols": cols,
+ "bytes": rows * cols,
+ }).Infof("writing numpy: %s", fnm)
+ npw.Shape = []int{rows, cols}
+ npw.WriteInt8(out)
+ err = bufw.Flush()
+ if err != nil {
+ return err
+ }
+ return output.Close()
+}
+
+func allele2homhet(colpair [2][]int8) {
+ a, b := colpair[0], colpair[1]
+ for i, av := range a {
+ bv := b[i]
+ if av < 0 || bv < 0 {
+ // no-call
+ a[i], b[i] = -1, -1
+ } else if av > 0 && bv > 0 {
+ // hom
+ a[i], b[i] = 1, 0
+ } else if av > 0 || bv > 0 {
+ // het
+ a[i], b[i] = 0, 1
+ } else {
+ // ref (or a different variant in same position)
+ // (this is a no-op) a[i], b[i] = 0, 0
+ }
+ }
+}
+
+type onehotXref struct {
+ tag tagID
+ variant tileVariantID
+ het bool
+ pvalue float64
+}
+
+const onehotXrefSize = unsafe.Sizeof(onehotXref{})
+
+// Build onehot matrix (m[variant*2+isHet][genome] == 0 or 1) for all
+// variants of a single tile/tag#.
+//
+// Return nil if no tile variant passes Χ² filter.
+func (cmd *sliceNumpy) tv2homhet(cgs map[string]CompactGenome, maxv tileVariantID, remap []tileVariantID, tag, chunkstarttag tagID) ([][]int8, []onehotXref) {
+ if maxv < 2 {
+ // everyone has the most common variant
+ return nil, nil
+ }
+ tagoffset := tag - chunkstarttag
+ coverage := 0
+ for _, cg := range cgs {
+ if cg.Variants[tagoffset*2] > 0 && cg.Variants[tagoffset*2+1] > 0 {
+ coverage++
+ }
+ }
+ if coverage < cmd.minCoverage {
+ return nil, nil
+ }
+ obs := make([][]bool, (maxv+1)*2) // 2 slices (hom + het) for each variant#
+ for i := range obs {
+ obs[i] = make([]bool, len(cmd.cgnames))
+ }
+ for cgid, name := range cmd.cgnames {
+ cgvars := cgs[name].Variants
+ for v := tileVariantID(2); v <= maxv; v++ {
+ if remap[cgvars[tagoffset*2]] == v && remap[cgvars[tagoffset*2+1]] == v {
+ obs[v*2][cgid] = true
+ } else if remap[cgvars[tagoffset*2]] == v || remap[cgvars[tagoffset*2+1]] == v {
+ obs[v*2+1][cgid] = true
+ }
+ }
+ }
+ var onehot [][]int8
+ var xref []onehotXref
+ for homcol := 4; homcol < len(obs); homcol += 2 {
+ for het := 0; het < 2; het++ {
+ p := pvalue(obs[homcol+het], cmd.chi2Cases)
+ if cmd.chi2PValue < 1 && !(p < cmd.chi2PValue) {
+ continue
+ }
+ onehot = append(onehot, bool2int8(obs[homcol+het]))
+ xref = append(xref, onehotXref{
+ tag: tag,
+ variant: tileVariantID(homcol / 2),
+ het: het == 1,
+ pvalue: p,
+ })
+ }
+ }
+ return onehot, xref
+}
+
+func bool2int8(in []bool) []int8 {
+ out := make([]int8, len(in))
+ for i, v := range in {
+ if v {
+ out[i] = 1
+ }
+ }
+ return out
+}
+
+// convert a []onehotXref with length N to a numpy-style []int32
+// matrix with N columns, one row per field of onehotXref struct.
+//
+// Hom/het row contains hom=0, het=1.
+//
+// P-value row contains 1000000x actual p-value.
+func onehotXref2int32(xrefs []onehotXref) []int32 {
+ xcols := len(xrefs)
+ xdata := make([]int32, 4*xcols)
+ for i, xref := range xrefs {
+ xdata[i] = int32(xref.tag)
+ xdata[xcols+i] = int32(xref.variant)
+ if xref.het {
+ xdata[xcols*2+i] = 1
+ }
+ xdata[xcols*3+i] = int32(xref.pvalue * 1000000)
+ }
+ return xdata
+}
+
+// transpose onehot data from in[col][row] to numpy-style
+// out[row*cols+col].
+func onehotcols2int8(in [][]int8) []int8 {
+ if len(in) == 0 {
+ return nil
+ }
+ cols := len(in)
+ rows := len(in[0])
+ out := make([]int8, rows*cols)
+ for row := 0; row < rows; row++ {
+ outrow := out[row*cols:]
+ for col, incol := range in {
+ outrow[col] = incol[row]
+ }
+ }
+ return out
+}
+
+// Return [2][]uint32{rowIndices, colIndices} indicating which
+// elements of matrixT[c][r] have non-zero values.
+func onehotChunk2Indirect(matrixT [][]int8) [2][]uint32 {
+ var nz [2][]uint32
+ for c, col := range matrixT {
+ for r, val := range col {
+ if val != 0 {
+ nz[0] = append(nz[0], uint32(r))
+ nz[1] = append(nz[1], uint32(c))
+ }
+ }
+ }
+ return nz
+}