2b:null 2c:["$","title",null,{"children":"O*Net Skills-Occupation Matrix | Sam Smith | Observable"}] 31:T17e0,// cell: First nested svg: treat the entire page as an svg and lay out items within isaated elements // including: two svg's, a text area, and buttons // 6/9/21 Started this; 6/12 addint dividers mainPageNested = { const container = html`

` const svgMain = d3.select(container) .append("svg") .attr("viewBox", `0 0 ${obscfg.widthMax < width ? obscfg.widthMax : width} ${obscfg.height + 40}`) svgMain.append("text") .attr("y", 20) .text("this is the outer svg") const mainGroup = svgMain .append("g") .attr("transform", `translate(${tmpShift})`) // const svg1 = svgMain // d3.select(svgMain) const svg1 = mainGroup // d3.select(svgMain) .append("svg") .attr("viewBox", `0 0 ${obscfg.widthMax < width ? obscfg.widthMax : width} ${obscfg.height * 0.8}`) let arEntropy = [] // entropy array - for each occupation displayed store value im-code * 3 + lv-code // Loop through selected occupation ID's and display each as vertical column: // 7/14/21 gettting high skill level where not expected; need to identify high-skill occup // get avg and then see which are sig above let sumImLv = 0 let numImLv = 0 let avgImLv = 0 obsArSelOccupIds.forEach((oc, ocIdx) => { if (ocIdx < 100000) { // test: 3) { if (ocIdx < 3) console.log("main Doing occup " + oc) const myPts = fnGetPoints(oc) if (ocIdx < 3) console.log("main Doingponts " + myPts) arEntropy.push(myPts) // see if this is useful!! // Display Single occupation with skills in vertical column svg1.append("g") .selectAll("rect") .data(myPts) .join("path") // why not enter()? .attr("d", (d, i) => { if (i < 35) { return fnGetPath(20 + ocIdx * obscfg.pxHor, i * obscfg.pxVert, d.lvVal, obscfg.pxHor, obscfg.pxVert) } else { // the occupation index rect hgt = numAbv in imVal + x * numHigh in lvVal // const myy = i * obscfg.pxVert +2 const myShape = 2 // (vertical rect) const myh = d.imVal + d.lvVal * 2 // note fix color later... // console.log("main socco l index: " + i + " " +d.imVal) let myPath = d3.path() const x = 20 + ocIdx * obscfg.pxHor const y = 35 * obscfg.pxVert + 10 const h = d.imVal + 2 * d.lvVal // im and lv for this item are num abv and high let metric = d.imVal + 2 * d.lvVal sumImLv += metric if (metric > 30) console.log("IMLV High for " + oc + " = " + metric) numImLv += 1 myPath.moveTo(x + obscfg.pxHor * 0.2, y + obscfg.pxVert * 0.2) // start upper left myPath.lineTo(x + obscfg.pxHor * 0.8, y) myPath.lineTo(x + obscfg.pxHor * 0.8, y + h) myPath.lineTo(x + obscfg.pxHor * 0.2, y + h) myPath.closePath() return myPath // return fnGetPath(20 + ocIdx * obscfg.pxHor, yForIndex, myShape, obscfg.pxHor, myh) } }) .attr("stroke", d => obscfg.colorsLv[d.lvVal]) .attr("stroke-width", 0.8) .attr("fill", (d, i) => { if (i < 35) { return obscfg.colorsLv[d.lvVal] } else { return "green" } }) } }) // assessing high im-lv get avg avgImLv = sumImLv / numImLv console.log("*** avg imlv = " + avgImLv) // Entropy work: // console.log("ENTROPY ", arEntropy) const entValues = fnCalcEntropy(arEntropy) console.log("Get it? ") // *** Dividers // ** Vertical dividers for Occupation Groups (if not Random) if (obsOccupSeq != "Random") { svg1.selectAll(".vertLine") .data(obsArOccupGrpIndices) .enter() .append('line') .attr("class", "vertLine") .attr('stroke', 'orange') .attr('stroke-width', 2.0) .attr('x1', d => 20 + d * obscfg.pxHor) .attr('y1', d => 10) .attr('x2', d => 20 + d * obscfg.pxHor) .attr('y2', d => obscfg.height * 0.75) } // ** Horizontal dividers between Skill Groups const skillSeq = obsSkillSeq === "O*Net Sequence" ? obscfg.divHorSkillsONet : obscfg.divHorSkillsOccO console.log("div for sklls ", obscfg.divHorSkillsOccO) svg1.selectAll('.horLine') .data(skillSeq) .enter() .append('line') .attr("class", "horLine") .attr('stroke', 'purple') .attr('stroke-width', 2.0) .attr('x1', 20) .attr('y1', d => d.end * obscfg.pxVert + 2) .attr('x2', width * 0.95) .attr('y2', d => d.end * obscfg.pxVert + 2) // Mega-Slider - parameters units are 1 px per occup const scaleW = obsArSelOccupIds.length // 1 px each const numDisp = width/obscfg.pxHor const center = width/2 const scaleX = center - scaleW/2 const sliderW = numDisp const sliderX = scaleX // at begin, the slider will be at left console.log("wid " + width + " " + obsArSelOccupIds.length) console.log("xxxscale " + numDisp + " " + scaleX + " " + scaleW) //const svg2 = svgMain // d3.select(svgMain) const svg2 = mainGroup .append("svg") .attr("viewBox", `0 0 ${obscfg.widthMax < width ? obscfg.widthMax : width} ${obscfg.height * 0.2}`) // Slider Rect - outer and inner slider rects: let scaleRect = svg2.append("rect") .attr("x", scaleX) .attr("y", 260) // why is this not working? obscfg.height -50) .attr("width", scaleW) .attr("height", 10) .attr("fill", "#780a0a") .attr("opacity", 0.50) .attr("stroke", "gray") .attr("stroke-width", 1.0) let sliderRect = svg2.append("rect") .attr("id", "slider") .attr("x", sliderX) .attr("y", 258) .attr("width", sliderW) .attr("height", 14) .attr("fill", "#fff7c2") // .attr("opacity", 0.80) .attr("stroke", "gray") .attr("stroke-width", 1.0) .on("click", sliderClick) .call(drag) let testrRect = svg2.append("rect") .attr("id", "sliderTst") .attr("x", 0) .attr("y", 258) .attr("width", sliderPctDisp/3) .attr("height", 14) .attr("fill", "blue") // .attr("opacity", 0.80) .attr("stroke", "gray") .attr("stroke-width", 1.0) /* const svgMsg = svgMain.append("svg") svgMsg .append("text") .attr("x", 50) .attr("y", 50) .text("Will this worK?") */ return container }32:T81f,## About SOC and O*Net ### Standard Occupational Classification (SOC) and the O*Net Online System There are 35 skills and 997 occupations, organized by the federal Standard Occupational Classificaiton (SOC) System and the O*Net online service into 5 skill sets and 22 occupations. The ontological objective is to organize the skills and occupations along BFO-based ontological lines to see if a more "reason-able" arrangement would be beneficial. - Skills are divided into 5 groups in the O*Net System by horizontal lines: - Basic, - Social, - Technical (which includes Complex Problem Solving), - Systems, - Resource Management. - The proposed ontological grouping of skills is also 5 groups based on a gradient of cognitive challenge for each skill, with the most challenging at the top: - Advanced: most cognitively challenging skills, including Complex Problem Solving and selected skills from the Basic, Technical and Systems groups; 10 total. - RM: challenging Resource Management; 4 total. - Sound: less challenging Basic; 7 total. - System: less challenging Systems; 6 total. - Tech: less challenging technical skills; 8 total with 4 at one level and 4 at the lowest level, for a total of 35. Showing all occupations is not possible, so they may be filtered in two ways: - modulo-4 249 at a time, selecting either residue 0 or 2 (eg 14 modulo = remainder 3 and residue 2). - by O\*Net Major Group (of which there are 22 non-military-specific groups) within an ontological grouping (3-level hierarchy with two main divisions, four sub-divisions and ten sub-sub-divisions). Each mark represents a skill-occupation pairing with the following legend: - **Importance** is shown by **shape**, upper left triangle for high, lower left triangle for "above" and rectangle for low. Above is between an average importance for that skill and one standard deviation above the average. - **Level of expertise** is shown by **color**, red for high, blue for above average, gray for below average metric for that skill level of expertise. 33:T6f1,// cell: Drag object of functions to effect the drag operation on slider rece // and translate display accordingly // 2021-06-13 See Word doc on doing this Ntbk (2021-06-13) Drag SVG as Group drag = { function dragstarted(event, d) { // upon click to drag, the group moves horizontally to some point before dragging // what it is doing is positioning the g at the point of the click; can this be overridden and // only capture x,y when the mouse is dragged? console.log("drag start: How to avoid any move? " + event.x) d3.select(this).attr("stroke", "black") } function dragged(event, d) { if (false) console.log("what is in event? ", event.x) // translate only the x dimension: console.log("dragged " + event.x + " THIS.... ", d3.select(this)) // d3.select(this).raise().attr("transform", `translate(${event.x})`) d3.select(this).attr("x", event.x) // did not work right: ("transform", `translate(${event.x})`) } function dragended(event, d) { // get x of mainGroup first determine delta x const priorX = d3.select("#sliderTst") console.log("Is there an event here? ", event) console.log("Here is prior rect obj ", priorX) console.log("Here is prior rect val " + priorX._groups[0][0].attributes.x.nodeValue) const deltaX = event.x - priorX.x console.log("zzzz ", deltaX) // translate the mainGroup by a delta: slider dx will mean - test for now // change of x in group = (newSilderX - oldSliderX) let test = d3.select("#sliderTst") .attr("transform", `translate(40)`) .attr("fill", "green") d3.select(this).attr("stroke", "gray") // reset } return d3.drag() .on("start", dragstarted) .on("drag", dragged) .on("end", dragended) }34:T5a4,// cell: fn to create a shape path, one of three shapes based on imType: // imlow, imabv, imhigh >> changed 6/11/21 to 0, 1, 2 function fnGetPath(x, y, imType, boxW, boxH) { let myPath = d3.path() // 6/6/21 use triangle at bottom 90% pointing up to 80% of box height if (imType === 0) { myPath.moveTo(x, y + boxH * 0.9) myPath.lineTo(x + boxW/2, y + boxH * 0.2) myPath.lineTo(x + boxW, y + boxH * 0.9) myPath.closePath() } // 6/6 use horizontal bar box width x 30 % box height 40 % from top if (imType === 1) { // replace with circle myPath.moveTo(x + boxW * 0.1, y + boxH * 0.4) // 6/12 trying full width, almost! myPath.lineTo(x + boxW * 0.8, y + boxH * 0.4) myPath.lineTo(x + boxW * 0.8, y + boxH * 0.7) myPath.lineTo(x + boxW * 0.1, y + boxH * 0.7) myPath.closePath() } // for abv, circle of radius = boxW/2, start point at right side of box in middle /* if (imType === "xxxx) { console.log("creating circle") // myPath.moveTo(x, y) myPath.arc(x + boxW, y + boxH/2, boxW/2, 0, Math.PI * 2) // myPath.arc(boxW, boxH/2, boxW/2, 0, Math.PI * 2) } */ // for high, rect within box if (imType === 2) { myPath.moveTo(x + boxW * 0.2, y + boxH * 0.2) // start upper left myPath.lineTo(x + boxW * 0.8, y + boxH * 0.2) myPath.lineTo(x + boxW * 0.8, y + boxH * 0.8) myPath.lineTo(x + boxW * 0.2, y + boxH * 0.8) myPath.closePath() } return myPath }35:T765,// cell: Read through 61k skill-occup recs and build dict by occup ID, with im and lv metric for each skill. // dict value is im and lv arrays each 35 long representing metric for each of 35 skills dictOccupSkills = { /* const mySkillOccup = await FileAttachment( "Obs Viz Skill-Occup_RND (2021-05-19)-1.csv" ).csv(); */ let myDict = {}; // {im: [36], lv: [36} -- 35 im and lv values skipping position zero } data_SkillOccup.forEach((row, i) => { if (i < 50000) { const myOccupId = row.SOC_Code; const skillIdx = dictSkillId2Idx[row.Element_ID]; const val = parseFloat(row.Data_Value); const imlvId = row.Scale_ID == "IM" ? "im" : "lv" // IM or LV index // add occup with both im and lv arrays if not there console.log("doing " + row.Element_ID + " idx " + skillIdx) if (! myDict.hasOwnProperty(myOccupId)) { // myDict[myOccupId] === undefined) { myDict[myOccupId] = {} myDict[myOccupId].im = new Array(36).fill(0); // zero not used so skill idx is index console.log("#### Epty? ", myDict[myOccupId].im) myDict[myOccupId].lv = new Array(36).fill(0); console.log("#### Epty LV? ", myDict[myOccupId].lv) console.log("HHHHERE ", myDict[myOccupId]) console.log("Add ", myDict); } // assign metric from data_SkillOccup row to dict for respective type IM or LV // NOTE: Index here starts with entry one (skill array goes 1-35) if (imlvId === "im") { myDict[myOccupId].im[skillIdx] = val } else { myDict[myOccupId].lv[skillIdx] = val } console.log("upd ", myDict[myOccupId]) } //console.log("count") }); console.log("build array complete: " + Object.entries(myDict).length + ", get Stats:"); // fnClearStats() // fnCalcStats() return myDict; } 36:T103f,// cell: Fn to re-scan data_SkillOccup twice, first to get sums and averages by skill, then get std dev // 6/2/21 this is self-contained, uses only skill-occupation file data, dictSkillsIdx, no arguments // changed from function to a calculated object: no; how is this done to create an object with code? function fnCalcStatsBySkill() { let numNonZero = 0 let stobj = {} stobj.skillCount = { im: new Array(36).fill(0), lv: new Array(36).fill(0) } console.log("Sk Counts: ", stobj.skillCount) stobj.skillSum = { im: new Array(36).fill(0), lv: new Array(36).fill(0) } stobj.skillAvg = { im: new Array(36).fill(0), lv: new Array(36).fill(0) } stobj.skillStdDev = { im: new Array(36).fill(0), lv: new Array(36).fill(0) } let totCountIm = 0 let totCountLv = 0 let totSumIm = 0 let totSumLv = 0 const diagLevel = 0 // 1 or more console logging // First Pass: calculate count and sums, then average per skill for IM and LV let tstSkillId = "2.A.1.e" // test for mathematical skill let tstCount = 0 // num occup recs let tstSum = 0 // sum of metrics for im or lv const tstType = "lv" // im or lv data_SkillOccup.forEach((row, i) => { const myOccupId = row.SOC_Code; const skillIdx = obsStatsBySkillIdx[row.Element_ID]; const val = parseFloat(row.Data_Value); const imlvId = row.Scale_ID === "IM" ? "im" : "lv" // IM or LV index if (imlvId === "im") { totCountIm += 1 totSumIm += val stobj.skillCount.im[skillIdx] += 1 stobj.skillSum.im[skillIdx] += val } else { totCountLv += 1 totSumLv += val stobj.skillCount.lv[skillIdx] += 1 stobj.skillSum.lv[skillIdx] += val } if (imlvId === tstType && row.Element_ID === tstSkillId) { tstCount += 1 tstSum += val if (i < 5) console.log("have sk " + tstSum) } }) // report test skill results: const avg = tstSum / tstCount console.log("test for skill " + tstSkillId + " cnt: " + tstCount + " " + avg) for (let i = 1; i < 36; i++) { if (stobj.skillCount.im[i] > 0) { stobj.skillAvg.im[i] = stobj.skillSum.im[i] / stobj.skillCount.im[i]; } if (stobj.skillCount.lv[i] > 0) { stobj.skillAvg.lv[i] = stobj.skillSum.lv[i] / stobj.skillCount.lv[i]; } /* console.log("cacld avgs IM " + Math.floor(stobj.skillSum.im[i]) + " c: " + stobj.skillCount.im[i] + " avg " + Math.floor(10 * stobj.skillAvg.im[i])/10) console.log("cacld avgs LV " + Math.floor(stobj.skillSum.lv[i]) + " c: " + stobj.skillCount.lv[i] + " avg " + Math.floor(10 * stobj.skillAvg.lv[i])/10) */ } // Second Pass: calculate Std Dev of IM and LV metric for each skill // Re-scan skill-occup to accuulate square of diff from mean data_SkillOccup.forEach((row, i) => { // get idx for occup skill const mySkillIdx = dictSkillsIdx[row.Element_ID]; const val = parseFloat(row.Data_Value); const imlvId = row.Scale_ID == "IM" ? "im" : "lv" // IM or LV index if (imlvId === "im" && stobj.skillCount.im[mySkillIdx] > -1) { // if zero let it count stobj.skillStdDev.im[mySkillIdx] += Math.pow( val - stobj.skillAvg.im[mySkillIdx], 2); } if (imlvId === "lv" && stobj.skillCount.lv[mySkillIdx] > -1) { stobj.skillStdDev.lv[mySkillIdx] += Math.pow( val - stobj.skillAvg.lv[mySkillIdx], 2); } }); for (let i = 1; i < 36; i++) { if (stobj.skillCount.im[i] > 0) { stobj.skillStdDev.im[i] = Math.sqrt( stobj.skillStdDev.im[i] / stobj.skillCount.im[i]) } if (stobj.skillCount.lv[i] > 0) { stobj.skillStdDev.lv[i] = Math.sqrt( stobj.skillStdDev.lv[i] / stobj.skillCount.lv[i]) } } if (diagLevel > 0) { for (let i = 0; i < 36; i++) { console.log("Index " + i + " IM " + stobj.skillCount.im[i] + " avg " + Math.floor(10 * stobj.skillAvg.im[i])/10 + " stdv " + Math.floor(1000 * stobj.skillStdDev.im[i])/1000); } for (let i = 0; i < 36; i++) { console.log("Index " + i + " LV " + stobj.skillCount.lv[i] + " avg " + Math.floor(10 * stobj.skillAvg.lv[i])/10 + " stdv " + Math.floor(1000 * stobj.skillStdDev.lv[i])/1000); } } return stobj }37:T763,// cell: Function to get occup index from dictOccupSkills; // for each skill within occup, if im > low, get numLvlAbv and numLvHigh function fnCalcStatsByOccup() { let dict_OccupIndex = {} // index with occupId as key and following values: numAbv, numHigh, (x position? calculate!) // OOPS: NOT THIS: dictOccupSkills.forEach((occup, j) => { let j = 0 // console.log("getting started: ", obsStatsBySkill ) for (const [key, val] of Object.entries(dictOccupSkills)) { // do later: dict_OccupIndex[occup.SOC_CODE] = { numImOk: 0, numLvAbv: 0, numLvHigh: 0, index: 0 } let numImOk = 0 let numLvAbv = 0 let numLvHigh = 0 // if (j < 3) console.log("xxxxx: " + j + " " + key, val) for (let i = 0; i < 36; i++) { if (val.im[i] <= obsStatsBySkill.skillAvg.im[i]) { // skip, only process if importance of skill is above low } else { numImOk += 1 if (val.lv[i] >= obsStatsBySkill.skillAvg.lv[i] + obsStatsBySkill.skillStdDev.lv[i]) { numLvHigh += 1 } else if (val.lv[i] > obsStatsBySkill.skillAvg.lv[i]) { // we know not high, so must be abv numLvAbv += 1 } } } j += 1 // update the dict_OccupIndex with results const indexValHigh = 2.25 // index value per high level = 2; try various values to see effect const newVals = { numImOk: numImOk, numLvAbv: numLvAbv, numLvHigh: numLvHigh, index: numLvAbv + indexValHigh * numLvHigh} if (j < 6) console.log("Resulting index for " + j + ": ", newVals) dict_OccupIndex[key] = newVals } let count = 0, sum = 0, min = 999, max = 0 for (const [key, val] of Object.entries(dict_OccupIndex)) { count += 1 sum += val.index if (val.index < min) min = val.index if (val.index > max) max = val.index } console.log(`min: ${min}, max: ${max}, avg: ${sum/count}`) return dict_OccupIndex }38:T7f2,// cell: function to calculate entropy on the whole matrix, regardless of occup group and skill group // hypothesis is that organization will reduce entropy // input: array for each displayed occup, imVal and lvVal // output: array of two numbers: total occupational entropy and total skill entropy // entropy is variance along axis: for occup, sqrt of (sum of (this point - point to right)**2) / num pts // for skills: sqrt of (sum of this point - point below)**2 / num pts (35 constant)) function fnCalcEntropy(arEntropy) { let entOccup = 0 // total entropy across occupaitons - ALL skills let entOccupPerSkill = Array(36).fill(0) // total entropy across al occupations for EACH SKILL let entSkills = 0 const numOccup = arEntropy.length // console.log("getting occup ent ", arEntropy) for (let ocIdx = 0; ocIdx < numOccup - 1; ocIdx++) { // do not process last point for (let skillIdx = 1; skillIdx < 36; skillIdx++) { if (skillIdx < 200) { let mypt = arEntropy[ocIdx][skillIdx] let myptNext = arEntropy[ocIdx + 1][skillIdx] const myptVal = Math.pow(mypt.imVal * 3 + mypt.lvVal - myptNext.imVal * 3 + myptNext.lvVal, 2) entOccup += myptVal entOccupPerSkill[skillIdx] += myptVal } } } console.log("variance...." + entOccup) console.log("var per skill ", entOccupPerSkill) entOccup = Math.sqrt(entOccup/arEntropy.length) console.log("Ent occup... " + entOccup) let avgEntPerSkill = 0 for (let i = 1; i < 36; i++) { entOccupPerSkill[i] = Math.sqrt(entOccupPerSkill[i]/arEntropy.length) console.log("Ent / skill " + i + " " + entOccupPerSkill[i]) avgEntPerSkill += entOccupPerSkill[i] } avgEntPerSkill = avgEntPerSkill / 35 console.log("Occup Ent per skill: ", entOccupPerSkill) console.log("avg occup ent per skill: " + avgEntPerSkill) // for first skill occup is 3.558; for all skills: 29.99 ... is that good? // for all first run ONet and same for skills, variance is LESS! 19.148 ... return ([ entOccup, 0]) }39:T5a7,// cell: Scan obsArSelOccupIds, retrieve group identies and determine index at which groups change // returns an array of occupation indices witin currently selected occups for vertical grooup lines // input specifies "Major O*Net Group", "OccO Onto Group", "Random" obsArOccupGrpIndices = { let arVertIndices = [] let isONet = true // default true to indicat O*Net selected, false => Onto group sequence console.log("getting grp indices for " + obsOccupSeq) if (obsOccupSeq === "Random") return; // do nothing - no groups! if (obsOccupSeq === "Major O*Net Group") { isONet = true } else { isONet = false } // First get the occupation info for the selected occupId's andn sort by MajGrp or OntoGrp let arOccupGrps = [] obsArSelOccupIds.forEach((ocId, i) => { const oc = dict_Occup[ocId] const ocGrp = isONet ? oc.MajGrp : oc.OntoGrp arOccupGrps.push(ocGrp) }) let priorGrp = "" arOccupGrps.sort().forEach((grp, i) => { /* if (isONet) { if (i < 3) console.log ("doing ONet ") currGrp = oc.MajGrp.substring(0, 2) } else { currGrp = oc.OntoGrp if (i < 3) console.log("doing occo " + currGrp) } */ if (i === 0) { priorGrp = grp } else { if (grp != priorGrp) { console.log("New group: " + grp + " idx " + i) arVertIndices.push(i) } } priorGrp = grp }) console.log("Indices: ", arVertIndices) return arVertIndices }3a:T547,// cell: Get the selected occcupation ids and order them by obsOccupSeq obsArSelOccupIds = { let arOccup = [] let numSelected = 0 let k = 0 for (const [key, val] of Object.entries(dict_Occup)) { // if (k++ < 5) console.log("Val ", val) switch (obsSelType) { case "Ref-200": if (val.isRefOccup === "ref") { arOccup.push({ occupId: key, SeqMajGrp: val.SeqMajGrp, SeqOntoGrp: val.SeqOntoGrp, SeqRandom: val.SeqRandom }) numSelected += 1 } break; case "Modulo-4, 0": break; default: break; } } console.log("Selected: " + obsSelType + "occ seq: " + obsOccupSeq + " seltd: " + numSelected) // sort occup based on seqOccup let sorted = [] // console.log("before ", arOccup) if (obsOccupSeq === "Major O*Net Group") { console.log("Here in sorting ref by onet ") arOccup.sort((a, b) => (b.SOC_Code > a.SOC_Code) ? -1 : 1) } else if (obsOccupSeq === "OccO Onto Group") { console.log("Here in sorting ref by OCCO ONTO ") arOccup.sort((a, b) => (b.SeqOntoGrp > a.SeqOntoGrp) ? -1 : 1) } else { // random console.log("random") arOccup.sort((a, b) => (b.SeqRandom > a.SeqRandom) ? -1 : 1) } arOccup.forEach(occup => { sorted.push(occup.occupId) }) // console.log("after ", sorted) return sorted }3b:Td9b,// cell: Function to get all display points for a given occupation id; SKIP SKILL ELEMENT ZERO! // Reference: obsSkillSeq = O*Net Sequence or else OccO onto, so order skills accordingly // 2021-06-11 hopefully getting close! // 2021-06-22 Definitely getting close - implementing onto skill sequence // 2021-06-25 Revised onto skills considerably and changed CSV headings, a mess! function fnGetPoints(occupId) { // myPoints will be the 35 skill indicators + 36th for occup index level, // each entry will be x, y and path // skillIndices will be array of skill idx for desired sequence, based on ONet index // (if sequence is onet it is the dict_Skills index) let myPoints = [] // new Array[37].fill(0) // symbol info for this occup const oc = dict_Occup[occupId] let numLvAbv = 0 let numLvHigh = 0 // stats array is zero based, 0-34 = skills and index 35 is num LvAbv and LvHi // above does not appear to be correct // 6/12 it looks like entry zero is not filled so skip it! // 6/22 retrieve the ith index from the skills index if O*Net but [ontoIdx] if OccO skill sequence // this is a bit tricky: skill info is in obsArSkillsAndStats; skillSeqIdx = sequenced indexed of sorted abilities // skillIdx = the skill's original O*Net index 1-35 console.log("what is skills and stats? ") // it is right there! for (let skillSeqIdx = 1; skillSeqIdx < 36; skillSeqIdx++) { // skillSeqIdx is the display (sorted) sequence // all needed is shape info. Get im and lv levels, 0, 1, 2 for low, abv, high and set path // NOTE: if Onto sequence is desired, the processing is done by onto index, so it will not be consecutive order: const skillIdx = obsSkillSeq === "O*Net Sequence" ? skillSeqIdx : obsArSkillIdxOnto[skillSeqIdx].skillOntoIdx // console.log("wwwwwahatt? ?? ", obsArSkillIdxOnto[1]) const currSkill = obsArSkillsAndStats[skillIdx] if (occupId === "11-1011.00") console.log("Onto chf ex: " + skillSeqIdx + " skill Onet idx: " + obsArSkillIdxOnto[1].skillOntoIdx + " skillIdx: " + skillIdx + " xx ", obsArSkillsAndStats[skillIdx]) let imVal = 0 // default if (oc.im[skillIdx] > currSkill.imAvg + currSkill.imStdDev) { imVal = 2 // imHigh } else if (oc.im[skillIdx] > currSkill.imAvg) { imVal = 1 // imAbv } let lvVal = 0 // default low if (oc.lv[skillIdx] > currSkill.lvAvg + currSkill.lvStdDev) { lvVal = 2 // lvHigh } else if (oc.lv[skillIdx] > currSkill.lvAvg) { lvVal = 1 // lvAbv } // get numbers for occup index if im > low for the skill if (oc.im[skillIdx] > currSkill.imAvg) { if (oc.lv[skillIdx] > currSkill.lvAvg + currSkill.lvStdDev) { numLvHigh += 1 /* console.log("High " + oc.lv[skillIdx] + " avg " + currSkill.lvAvg + " stdd " + currSkill.lvStdDev) */ } else if (oc.lv[skillIdx] > currSkill.lvAvg) { numLvAbv += 1 } } // we have results for this Occup-skill combination - add to myPoints myPoints.push({ imVal: imVal, lvVal: lvVal }) } // we have results for this occupation; push the two occupation index metrics // onto the array as element 36 with numLvAbv, numLvhigh in the two spots myPoints.push({ imVal: numLvAbv, lvVal: numLvHigh }) // order skill metric values by seqSkill // console.log("xxxx " + numLvAbv + " ", myPoints) return myPoints }3c:T446,// cell: Extract from obsArSkillsAndStats an array of skill indices but sorted by OntoIdx // the ith entry in array is the ONetIdx of the skill for this sorted position obsArSkillIdxOnto = { let arSkillIndices = [] // array of {ONetIdx: mm, OntoIdx: nn } that will be sorted by OntoIdx // let sortedSkills = [] // array where idx is the onto sequence and value is ONetIdx reference skillIdx arSkillIndices.push({ skillONetIdx: -1, skillOntoIdx: -1 }) // to fill position zero, unused, to sort as first(?) // if no-go do this: { skillIdx: nn, skillSeqIdx: mm } // NOTE: OntoIdx is string - convert to int obsArSkillsAndStats.forEach((skill, j) => { if (j > 0) { console.log("in ... " + j + " ", skill) arSkillIndices.push({ skillONetIdx: skill.skillONetIdx, skillOntoIdx: parseInt(skill.skillOntoIdx) }) } }) arSkillIndices.sort((a, b) => (b.OntoIdx > a.OntoIdx) ? -1: 1) // "standard" method arSkillIndices[0] = null arSkillIndices.forEach((s,i) => {if (i > 0) console.log("Seq " + i + " is ONet " + s.ONetIdx)}) return arSkillIndices // sorted(?) }3d:T163e,// cell: array with skill stats for avg, std deviation across all occupations // Input: data_Skills and dict_Occp with im, lv values for each skill // Output: array mySkills for each skill id, skill O*Net index (as read in), skillOntoIdx, and stats for avg, stdDev for im, lv // RECALL array begins with engry 1, zero is not used // Processing: two steps 1. create mySkills array empty, 2. scan dict_Occup and accumulate stats for each skill // // ** Now an array ** Update doco : Dict from skill id to skill index only - no title or group, just idx // 2021-06-10 will be pulled from data_Skills and sequenced based on obsSkillSeq // being either "Skill Onto Group" or not (O*Net seq) // 2021-06-11 no, we do not want to make this reactive to the skill sequence requested - just store both indices // revising: Why not at same time calculate the stats by skill? // 2021-06-11 yikes: we really need to access the info by index, not by skill id, so // make this an array in sequence by ONet index // 2021-06-25 revised onto skills and changed the skills csv headers! (Not working as of 7/1!) obsArSkillsAndStats = { // Step 1: creats empty output object mySkills let mySkills = [] // put an empty object in position zero: mySkills.push({}) /* let mySkillList = [] << EARLIER: sort was based on selection of skill sort sequence... no more if (obsSkillSeq === "Skill Onto Group") { mySkillList = data_Skills.sort((a, b) => b.SkillOntoIdx > a.SkillOntoIdx) } else { mySkillList = data_Skills.sort((a, b) => b.SkillOntoIdx > a.SkillOntoIdx) } */ // assign skill indices. NOTE Input must be in ONet Skill sequence as its index (+1) is used for ONetIdx data_Skills.forEach((row, i) => { const skillItem = { skillId: row.skillId, skillONetIdx: i + 1, skillOntoIdx: parseInt(row.skillOntoIdx), imAvg: 0, // count and sum are not needed! imStdDev: 0, lvAvg: 0, lvStdDev: 0 } mySkills.push(skillItem) }) // Step 2: scan dict_Occup to gather stats for each skill // 2a. stobj retains count, sum, avg and std dev for each skill let numNonZero = 0 let occupNoSkills = 0 let stobj = { // skill table with stats skillCount: { im: [], lv: [] }, // this is over=written; change later skillSum: { im: [], lv: [] }, skillAvg: { im: [], lv: [] }, skillStdDev:{ im: [], lv: [] }, } /* the fill with objects does not seem to work right; do in loop stobj.skillCount = { im: new Array(36).fill(0), lv: new Array(36).fill(0) } stobj.skillSum = { im: new Array(36).fill(0), lv: new Array(36).fill(0) } stobj.skillAvg = { im: new Array(36).fill(0), lv: new Array(36).fill(0) } stobj.skillStdDev = { im: new Array(36).fill(0), lv: new Array(36).fill(0) } console.log("Sk obj......: ", stobj) // NOTE: This will show values AFTER processing!! StdDev in NaN! WHY?? */ // for (let i = 0; i < 36; i++) { stobj.skillCount = { im: new Array(36).fill(0), lv: new Array(36).fill(0) } stobj.skillSum = { im: new Array(36).fill(0), lv: new Array(36).fill(0) } stobj.skillAvg = { im: new Array(36).fill(0), lv: new Array(36).fill(0) } stobj.skillStdDev = { im: new Array(36).fill(0), lv: new Array(36).fill(0) } // } console.log("Sk obj.zzzz.....: ", stobj) // 2b. first pass of dict_Occup to get counts and average let testIdx = 0 for (const [key, val] of Object.entries(dict_Occup)) { if (testIdx < 4) console.log("VALLLLLL ", val) testIdx += 1 let tot = val.im.reduce((a, b) => a + b, 0) if (tot > 0) { for (let i = 0; i <= 36; i++) { stobj.skillCount.im[i] += 1 // count even if zero (?) stobj.skillCount.lv[i] += 1 stobj.skillSum.im[i] += val.im[i] stobj.skillSum.lv[i] += val.lv[i] } if (testIdx < 4) console.log("idx " + testIdx, stobj.skillCount.im[2]) if (testIdx < 4) console.log("idx sum " + testIdx, stobj.skillSum.im[2]) } else { occupNoSkills += 1 } } console.log("Counts ", mySkills) // set avg's for (let i = 1; i < 36; i++) { stobj.skillAvg.im[i] = stobj.skillSum.im[i] / stobj.skillCount.im[i] stobj.skillAvg.lv[i] = stobj.skillSum.lv[i] / stobj.skillCount.lv[i] } // second pass to get std dev for (const [key, val] of Object.entries(dict_Occup)) { let tot = val.im.reduce((a, b) => a + b, 0) if (tot > 0) { for (let i = 1; i <= 36; i++) { stobj.skillStdDev.im[i] += Math.pow(val.im[i] - stobj.skillAvg.im[i], 2) stobj.skillStdDev.lv[i] += Math.pow(val.lv[i] - stobj.skillAvg.lv[i], 2) } } else { // occupNoSkills += 1 } } // get sqrt now for (let i = 1; i < 36; i++) { stobj.skillStdDev.im[i] = Math.sqrt(stobj.skillStdDev.im[i] / stobj.skillCount.im[i]) stobj.skillStdDev.lv[i] = Math.sqrt(stobj.skillStdDev.lv[i] / stobj.skillCount.lv[i]) // now enter results in mySkills mySkills[i].imAvg = stobj.skillAvg.im[i] mySkills[i].imStdDev = stobj.skillStdDev.im[i] mySkills[i].lvAvg = stobj.skillAvg.lv[i] mySkills[i].lvStdDev = stobj.skillStdDev.lv[i] } if (true) { // obscfg.diagLevel > 0) { console.log("Stobj " + occupNoSkills) for (let i = 1; i < 36; i++) { console.log("Index " + i + " IM " + stobj.skillCount.im[i] + " avg " + Math.floor(10 * stobj.skillAvg.im[i])/10 + " stdv " + Math.floor(1000 * stobj.skillStdDev.im[i])/1000); } for (let i = 1; i < 36; i++) { console.log("Index " + i + " LV " + stobj.skillCount.lv[i] + " avg " + Math.floor(10 * stobj.skillAvg.lv[i])/10 + " stdv " + Math.floor(1000 * stobj.skillStdDev.lv[i])/1000); } } return mySkills }3e:T638,// cell: Loop through Skills-Occupancy file and analsyze skill patterns and statistics // returns: Object with stats by Skill and skill-index by occupaiton // 6/8/21: Add occupation index of above and hi skills function fnSkillsOccupAnalyze() { let numBySkillId = {} // create dict of count by skill id for (const [key, val] of Object.entries(dictSkillId2Idx)) { numBySkillId[key] = new Array(5).fill(0) } // get count of abilities by level <= 0.25, >1, >2, >3, >4 let numSkillOccup = 0 // console.log("aaaxx ", numBySkillId) data_SkillOccup.forEach((skoccup, i) => { numSkillOccup += 1 if (skoccup.Scale_ID === "LV") { // "IM") { const skillId = skoccup.Element_ID if (i < 3) console.log("sk " + skillId) const im = parseInt(skoccup.Data_Value) if (! numBySkillId.hasOwnProperty(skillId)) { console.log("ERROR missing skill id: " + skillId) } if (im > 0) numBySkillId[skillId][0] += 1 if (im > 1) numBySkillId[skillId][1] += 1 if (im > 2) numBySkillId[skillId][2] += 1 if (im > 3) numBySkillId[skillId][3] += 1 if (im > 4) numBySkillId[skillId][4] += 1 } }) let sumInResult = [0,0,0,0] for (const [key, val] of Object.entries(numBySkillId) ) { console.log("key " + key + " " + val) sumInResult[0] += val[0] sumInResult[1] += val[1] sumInResult[2] += val[2] sumInResult[3] += val[3] sumInResult[4] += val[4] } console.log("Res: tot: " + numSkillOccup, numBySkillId) console.log("xxx ", sumInResult) return numBySkillId } 3f:Ta8d,// cell: object with two array elements, arIm and arLv with 36 values = { num, avg, std dev } or each skill // Data is derrived from dict_Occup which already has the skill values for im and lv in separate arrays // (Pos 0 not used obsArSkillStats = { /* let arskill = { *** This fill may not have worked right!!! arIm: Array(36).fill({ num: 0, avg: 0, stdev: 0 }), arLv: Array(36).fill({ num: 0, avg: 0, stdev: 0 }) } */ let arskill = { arIm: [], arLv: [] } for (let i = 0; i < 36; i++) { arskill.arIm.push({ num: 0, avg: 0, stdev: 0 }) arskill.arLv.push({ num: 0, avg: 0, stdev: 0 }) } // first pass to get averages for each skill let numOccup = 0 let numZero = 0 for (const [key, val] of Object.entries(dict_Occup)) { if (numOccup < 3) console.log("dict occup ", val.im) numOccup += 1 if (numOccup === 1) console.log("xxx " + arskill.arIm[1].num) for (let i = 1; i < 36; i++) { if (val.im[i] > 0) { if (numOccup < 3) console.log("before addding one " + arskill.arIm[i].num) arskill.arIm[i].num += 1 if (numOccup < 3) console.log("addding one ", arskill.arIm[i]) arskill.arIm[i].avg += val.im[i] // get total, derive avg later } else { if (i === 1) numZero += 1 } if (val.lv[i] > 0) { arskill.arLv[i].num += 1 if (numOccup < 3) console.log("addding one ", arskill.arLv[i]) arskill.arLv[i].avg += val.lv[i] // get total, derive avg later } else { // if (i === 1) numZero += 1 } } if (numOccup < 3) console.log("My i's ", arskill.arIm) } // get averages for im and lv for (let i = 0; i < 36; i++) { arskill.arIm[i].avg = Math.floor(100 * arskill.arIm[i].avg / arskill.arIm[i].num) / 100 arskill.arLv[i].avg = Math.floor(100 * arskill.arLv[i].avg / arskill.arLv[i].num) / 100 } // second pass to calculate std dev as sqrt of average of squares val - avg for (const [key, val] of Object.entries(dict_Occup)) { for (let i = 1; i < 36; i++) { if (val.im[i] > 0) { arskill.arIm[i].stdev += Math.pow(val.im[i] - arskill.arIm[i].avg, 2) // get total, derive avg of squares later } if (val.lv[i] > 0) { arskill.arLv[i].stdev += Math.pow(val.lv[i] - arskill.arLv[i].avg, 2) } } } // get stddev as sqrt of average of squares for (let i = 0; i < 36; i++) { arskill.arIm[i].stdev = Math.floor(100 * Math.sqrt(arskill.arIm[i].stdev/ arskill.arIm[i].num)) / 100 arskill.arLv[i].stdev = Math.floor(100 * Math.sqrt(arskill.arLv[i].stdev / arskill.arLv[i].num)) / 100 } console.log("Num occup = " + numOccup + " no skill " + numZero) return arskill }40:T530,// cell: create dict with MajGrp as key and values {ONetIdx, RandomIdx} // Note: The RandomIdx is the sequence number of occupations in random order, based on SeqRandom value (string) // This must be converted from the random string value to a number 1 to 977 for consecutive indices obsEntMajGrpOccupIds = { let rand2OccupIdx = [] // first sort the occupation id's in SeqRandom (string converted to int) sequence go get the ONetIcx // that corresponds to the occupation in random sequence data_Occup.forEach(oc => { rand2OccupIdx.push({ OccupId: oc.SOC_Code, ONetIdx: parseInt(oc.SeqMajGrp), SeqRandom: parseInt(oc.SeqRandom), RandomIdx: 0 }) }) let myGrpOccupIds = {} rand2OccupIdx.sort((a, b) => b.SeqRandom > a.SeqRandom ? -1:1) rand2OccupIdx.forEach((obj, i) => obj.RandomIdx = i+1) data_Occup.forEach((oc, i) => { const intOccupId = parseInt(oc.SeqMajGrp) - 1 if (i < 3000) console.log("at " + intOccupId + " obj ", rand2OccupIdx[intOccupId].OccupId) if (myGrpOccupIds.hasOwnProperty(oc.MajGrp)) { myGrpOccupIds[oc.MajGrp].push({ ONetOccupId: oc.SOC_Code, RandomOccupId: rand2OccupIdx[intOccupId].OccupId }) } else { myGrpOccupIds[oc.MajGrp] = [{ ONetOccupId: oc.SOC_Code, RandomOccupId: rand2OccupIdx[intOccupId].OccupId }] } }) return myGrpOccupIds }41:Tb46,/* 7/2/21 5:50pm - worn out! got the "aggregate" sum of entropies for each group - skill entropy for each skill - group are calculated by fnCalcEntMajGrpSkills(ONet or Random) and results (sum only not recomputed running variance) is computed in obsResultsAggregate To do: process by group ? << think this through - if skills are aggregated, is that a good idea? I think so BUT: Do we get a running variance across skills? I think not! Best just to use a SUM!! Then once we have a sum per group, get the running variance for the groups Quite a number of cells need to be redone / deleted: */ obsResults1 = { const resONetIm = fnCalcEntMajGrpSkills("ONet") const resRandIm = fnCalcEntMajGrpSkills("Random") // Phase I: grand total entropy, all groups let sumForSkill5ONetIm = 0 let sumForSkill5RandIm = 0 let sumForSkillsONetIm = 0 let sumForSkillsRandIm = 0 for (let grpnum = 0; grpnum < resONetIm.length; grpnum++) { for (let skillnum = 1; skillnum < 36; skillnum++) { if (skillnum === 5) { sumForSkill5ONetIm += resONetIm[grpnum][skillnum] sumForSkill5RandIm += resRandIm[grpnum][skillnum] } sumForSkillsONetIm += resONetIm[grpnum][skillnum] sumForSkillsRandIm += resRandIm[grpnum][skillnum] } } // Phase IIa: Entropy for each Group, all skills // NOW: can the ONet results for each group be combined to yield an overall all-group entropy? // (this does not apply to the random case; however, since they are grouped similarly, calculate this as well) // process: get the running variance across groups // step one is get group ent across all skills: let sumForGrpsONetIm = [] let sumForGrpsRandIm = [] let priorONetIm = 0 let priorRandIm = 0 for (let grpnum = 0; grpnum < resONetIm.length; grpnum++) { for (let skillnum = 0; skillnum < 36; skillnum++) { } } /* for (let grpnum = 0; grpnum < resONetIm.length; grpnum++) { if (grpnum > 0) { sumForGrpsONetIm += Math.pow(resONetIm[grpnum] - priorONetIm, 2) console.log("RExx1111xxx " + resONetIm[grpnum] + " val " + priorONetIm) sumForGrpsRandIm += Math.pow(resRandIm[grpnum] - priorRandIm, 2) priorONetIm = resONetIm[grpnum] priorRandIm = resRandIm[grpnum] console.log("RExxxxx " + sumForGrpsONetIm + " val " + resONetIm[grpnum]) } } */ // Pase IIb: combine group entropies - get sum of squares then sqrt of avg // get average using 21 group differences in the 22 groups sumForGrpsONetIm = Math.sqrt(sumForGrpsONetIm / 21) sumForGrpsRandIm = Math.sqrt(sumForGrpsRandIm / 21) // Phase I results: // return { ONet: Math.round(sumForSkillsONetIm * 100)/100, Rand: Math.round(sumForSkillsRandIm * 100)/100 } // Phase II results: return { ONet: Math.round(sumForGrpsONetIm * 100)/100, Rand: Math.round(sumForGrpsRandIm * 100)/100 } }42:T974,// ARCHIVAL: function to get skill entropies for each group***** // cell: For each of the 22 ONet major-group-index-sets of desired sequence calculate LeafOntoEntropy // Param: seq is either ONet or Random // issue 1: dict_Occup is accessed by OccupId not index // issue 2: the seqRandom is a random number - needs to be sorted to get an index // 7/2/21 reference is now a dictionary by OccupId with occupid's for both ONet and Random function fnCalcEntMajSkillGrps(seq) { console.log("Hixxxx zzz") let grpEnt = 0 // for now make it the sum of skill variances Array(36).fill(0) let allGrpEnt = [] // array for all groups let numGrps = 0 // const occupLookup = Object.entries(dict_Occup) // will have array of [key, value] let arSumSquaresIm = Array(36).fill(0) // sum of sqares of adjecent occups for each of 35 skills skipping zero let arPriorIm = Array(36).fill(0) // im value of prior occup for each skill // Process each group, and within each group, process all occupations // process each group: for (const [key, val] of Object.entries(obsEntMajGrpOccupIds)) { if (numGrps < 25) { console.log("Doing group " + numGrps) let numOccup = 0 // process each occup: val.forEach((ref, j) => { const occupId = seq === "ONet" ? ref.ONetOccupId : ref.RandomOccupId const myOc = dict_Occup[occupId] // ascertain im has nonzero values let tot = myOc.im.reduce((a, b) => a + b, 0) if (tot > 0) { // get occup from dict_Occup if (numOccup < 4 && j < 3) console.log("doing occup " + occupId + " keyoc ", myOc.im) if (numOccup > 0) { // calculate "running variance" - degree of change from adjacent (leaf) value for (let i = 1; i < 36; i++) { //*** make 36 arSumSquaresIm[i] += Math.pow(myOc.im[i] - arPriorIm[i], 2) // console.log("im val= " + myOc.im[i] + " ri " + arPriorIm[i] + " Sq " + arSumSquaresIm[1]) } arPriorIm = [...myOc.im] // copies actual values; can we just use ref to prior occup? } } numOccup += 1 }) // get sqrt of average for (let i = 1; i < 36; i++) arSumSquaresIm[i] = Math.sqrt(arSumSquaresIm[i] / numOccup) numGrps += 1 allGrpEnt.push(arSumSquaresIm) } } console.log("result im: ", arSumSquaresIm) return allGrpEnt }43:T9f7,// *** this is a newer version I think? THE ONE USED is fnCalcEntMajSkillGrps << MIS-NAMED! // cell: For each of the 22 ONet major-group-index-sets of desired sequence calculate LeafOntoEntropy // which of these is used? // Param: seq is either ONet or Random // returns array of 22 groups each having ent figure for array of 25 skills // issue 1: dict_Occup is accessed by OccupId not index // issue 2: the seqRandom is a random number - needs to be sorted to get an index // 7/2/21 reference is now a dictionary by OccupId with occupid's for both ONet and Random function fnCalcEntMajGrpSkills(seq) { console.log("Hixxxx zzz") let grpEnt = 0 // for now make it the sum of skill variances Array(36).fill(0) let allGrpEnt = [] // array for all groups let numGrps = 0 // const occupLookup = Object.entries(dict_Occup) // will have array of [key, value] let arSumSquaresIm = Array(36).fill(0) // sum of sqares of adjecent occups for each of 35 skills skipping zero let arPriorIm = Array(36).fill(0) // im value of prior occup for each skill // Process each group, and within each group, process all occupations // process each group: for (const [key, val] of Object.entries(obsEntMajGrpOccupIds)) { if (numGrps < 25) { console.log("Doing group " + numGrps) let numOccup = 0 // process each occup: val.forEach((ref, j) => { const occupId = seq === "ONet" ? ref.ONetOccupId : ref.RandomOccupId const myOc = dict_Occup[occupId] // ascertain im has nonzero values let tot = myOc.im.reduce((a, b) => a + b, 0) if (tot > 0) { // get occup from dict_Occup if (numOccup < 4 && j < 3) console.log("doing occup " + occupId + " keyoc ", myOc.im) if (numOccup > 0) { // calculate "running variance" - degree of change from adjacent (leaf) value for (let i = 1; i < 36; i++) { //*** make 36 arSumSquaresIm[i] += Math.pow(myOc.im[i] - arPriorIm[i], 2) // console.log("im val= " + myOc.im[i] + " ri " + arPriorIm[i] + " Sq " + arSumSquaresIm[1]) } arPriorIm = [...myOc.im] // copies actual values; can we just use ref to prior occup? } } numOccup += 1 }) // get sqrt of average for (let i = 1; i < 36; i++) arSumSquaresIm[i] = Math.sqrt(arSumSquaresIm[i] / numOccup) numGrps += 1 allGrpEnt.push(arSumSquaresIm) } } console.log("result im: ", arSumSquaresIm) return allGrpEnt }44:Ta77,// cell: Read occupation CSV File and convert to JSON with csvParse // 2021-06-10 Add: arIM, arLV [35} for skill IM and LV values, also lvCountAbv, lvCountHigh // 2021-06-11 changing again to create dict with skill info at the same time by processing data_skillsOccup // NOTE: Skills in dict_Occup will be in ONet SEQUENCE; for display in Onto seq keep this in mind! dict_Occup = { // get occupation table, create a dict with occupId as key and then scan data_SkillOccup to fill in skill values let myDict = {} // this will create a dict for ALL occup - even the 130 or so which have no skill info data_Occup.forEach(row => { myDict[row.SOC_Code] = { MajGrp: row.MajGrp, SeqMajGrp: row.SeqMajGrp, SeqOntoGrp: row.SeqOntoGrp, SeqRandom: row.SeqRandom, isRefOccup: row.isRefOccup, isMake: row.isMake, Secondary: row.Secondary, OntoGrp: row.OntoGrp, Title: row.Title, DescriptionXXX: row.Description, im: new Array(36).fill(0), // store metric for each IM value / skill, not using [0] lv: new Array(36).fill(0), imCountAbv: 0, lvCountHigh: 0, } }) // scan data_SkillOccup and for each record's metric Data_Value update the dict_SkillOccup record for the OccupId let diag = false data_SkillOccup.forEach((row, i) => { if (i < 100000) { // higher than max 61k rows const myOccupId = row.SOC_Code; const skillIdx = dictSkillId2Idx[row.Element_ID].ONetIdx; // skillONetIdx; const val = parseFloat(row.Data_Value); const imlvId = row.Scale_ID == "IM" ? "im" : "lv" // IM or LV index // add occup with both im and lv arrays if not there if (diag) console.log("doing " + row.Element_ID + " idx " + skillIdx) /* if (! myDict.hasOwnProperty(myOccupId)) { // myDict[myOccupId] === undefined) { myDict[myOccupId] = {} myDict[myOccupId].im = new Array(36).fill(0); // zero not used so skill idx is index console.log("#### Epty? ", myDict[myOccupId].im) myDict[myOccupId].lv = new Array(36).fill(0); console.log("#### Epty LV? ", myDict[myOccupId].lv) console.log("HHHHERE ", myDict[myOccupId]) console.log("Add ", myDict); } */ // assign metric from data_SkillOccup row to dict for respective type IM or LV // NOTE: Index here starts with entry one (skill array goes 1-35) if (imlvId === "im") { myDict[myOccupId].im[skillIdx] = val } else { myDict[myOccupId].lv[skillIdx] = val } console.log("upd ", myDict[myOccupId]) } //console.log("count") }); console.log("build array complete: " + Object.entries(myDict).length + ", get Stats:"); return myDict } 45:T47c,// cell: Dict from skill id to skill index only - no title or group, just idx // 2021-06-10 will be pulled from data_Skills and sequenced based on obsSkillSeq // being either "Skill Onto Group" or not (O*Net seq) // 2021-06-11 no, we do not want to make this reactive to the skill sequence requested - just store both indices // 2021-06-13 this does not appear to be used - NO Referenced 15 times! But what does it have? // 2021-06-25 re-doing this for dict from ONet Skill Id (Element_Id such as A.2.b.2), skillONetIdx, skillOntoIdx dictSkillId2Idx = { let myDict = {} /* let mySkillList = [] if (obsSkillSeq === "Skill Onto Grou") { mySkillList = data_Skills.sort((a, b) => b.SkillOntoIdx > a.SkillOntoIdx) } else { mySkillList = data_Skills.sort((a, b) => b.SkillOntoIdx > a.SkillOntoIdx) } */ // assign skill indices. NOTE Input must be in ONet Skill sequence as its index (+1) is used for OntoIdx data_Skills.forEach((row, i) => { // key is ONet skill id (Element_ID in skill-occup file) => {onetIdx and Onto idx) myDict[row.skillId] = { ONetIdx: i + 1, OntoIdx: row.skillOntoIdx } }) return myDict }46:T6c1,// cell: Standard configuration settings plus operational variables for the app obscfg = { let myObscfg = { // operational app variables // where to draw horizontal lines separating skill groups, in ONet or OccO sequence // ONet sequence (as read-in) divHorSkillsONet: [ { cat: "Basic", start: 1, end: 10 }, { cat: "Social", start: 11, end: 16 }, { cat: "Technical", start: 17, end: 28 }, { cat: "Systems", start: 29, end: 31 }, { cat: "Resource Mgt", start: 32, end: 35 }, ], // Onto sequence AFTER sort by SkillOntoIdx: divHorSkillsOccO: [ { cat: "Advanced", start: 1, end: 10 }, // in O-Net D_Skills Master, Advanced { cat: "RM", start: 11, end: 14 }, { cat: "Sound", start: 15, end: 21 }, { cat: "Systems", start: 22, end: 27 }, { cat: "Tech", start: 28, end: 35 }, ], colorsLv: [ "gray", // lvlow "#00ff00" // green too faint "#0000ff", // lvabv blue "#ff0000", // lvhigh red ], // Input file names // file_occup: "", // file_skillOccup: "Obs Viz Skill-Occup_ONT (2021-05-19).csv", // no-go!! must be string // fattach_skillOccup: FileAttachment("mtcars.csv"), // see if this will work! // display variables widthMax: 1200, // if width > this, set widthApp to max // how to avoid circular: widthApp: widthMax < width ? widthMax : width, // application window width including margins // circular: widthNet: widthApp - obscfg.margin.left - obscfg.margin.right, // display window width height: 500, // for now, 1/5 of height... indexH: 30, // height of the display svg of occupation indices pxHor: 6, pxVert: 10, margin: {top: 25, right: 20, bottom: 35, left: 40}, diagLevel: 0, } return myObscfg } 47:Tda8,## Observable Notebook Self-documentation ### Main Display Cells - mainPageNested - Main display of matrix; ### Input Controls - Affecting Output Display - obsSelType = group of occupations to process: Ref-200, Modulo-4 (0 or 2 for first, third), others (later) - This controls the set of occupations processed by setting xxxxxyyyyzzz - obsOccupSeq = occupation sequence: Major O*Net Group, OccO Onto Group, or Random - This controls the sequence of occupations displayed horizontally - Upon change the occupations are sorted by Onto Group (***FIELD??) and vertical line dividers between occup groups are set in obArOccupGrpIndices - obsSkillSeq = O*Net sequence or Skill Onto Group - This controls the vertical ordering of skills, with indices between skill groups in divHorSkillsONet and divHorSkillsOccO ### Input Data, and Related Array or Dictionary - data_Occup; converted to dict_Occup - Note: This also contains the 36-entry arrays for 36 im and lv values (entry zero unused) - filename = O-Net B_Occupations SOC-Related (2021-06-10).csv - data_SkillOccup; remains as read from .json file, array of objects - filename = O-Net C_Skill-Occupation with Metrics (2021-06-10).csv - data_Skills; converted to dict_Skills << Note: dict_Skills appears NOT to be used! - filename = O-Net D_Skills_TreeOnto (2021-06-10).csv ### Derived Data: Processing Objects derived from Input - obsArSelOccupIds: the MAIN ordered list of occupation ids in the desired sequence (ONet or Onto) - obsArSkillsAndStats: Main reference for display of skills: skillId (from Element_ID in SkillOccup), ONetIdx (as-is), OntoIdx: Onto Seq and the average and standard distribution for each skill across all occupations. - obsArOccupGrpIndices: currently dispayed occupation indices at which groups change for vertical dividers - obsArSkillIdxOnto: array for each skill in ONTOLOGICAL order showing the ONetIdx (original, as-read) index for accessing skills table ### Output Entities that appear in Main Page - obsMessage -- attempt to in effect put console log output on display; did this work out? ### Functions - fnSkillsOccupAnalyze - fnOccupAnalyze - drag {} - object that contains several functions: dragstarted, draffed, dragended to handle the drag event - use or get rid of: dictOccupSkills, obsStatsBySkill, fuCalcStatsBySkill, obsStatsByOccup, finCalcStatsByOccup - *** OR: usee calc stats to do entropy!! - fnCalcStatsBy ### Imports - Tooltip from "@clhenrick/tooltip-component" ### Standard Notebook cells - d3 - obscfg - configuration info (window size, margins, etc) plus app-specific constants: - Skill level colors - divHorSkillsONet - the indices at which skill group horizontal line appears in O*Net sequence change - divHorSkillsOccO - same, when in OccO Onto skill sequence Other? ### Coding Standards - obscfg execution options for margin, height, width if not full - obs prefix for an app variable – assumed to be an object not array - obsAr Prefix for an app variable that is an array of values or objects - data_ Prefix for data read in from JSON or CSV as array of objects - dict_ Prefix for input data converted to a dictionary with key, value - fn Prefix for a cell that is a function - obsFn Prefix for a cell that is an object containing functions - Example: drag has dragstarted, dragged, and dragend functions - Avoid variable names that are identical to common library variables (eg. x, y, value, key) 48:[{"id":"8d6a55e655e82b0bc808556ad2640de57d83284ca0a387d85f07efcb5366fcdfa3216b46abecda29a1c651c823aa6e6fb47f00944b3e577925133742ffa99d05","href":"https://static.observableusercontent.com/files/8d6a55e655e82b0bc808556ad2640de57d83284ca0a387d85f07efcb5366fcdfa3216b46abecda29a1c651c823aa6e6fb47f00944b3e577925133742ffa99d05","name":"O-Net B_Occupations SOC-Related (2021-07-14).csv","type":"text/csv","lastModified":1626307363954.564,"size":303080},{"id":"124b5d268e329cd4ae11af83cb4a4f181a51246f5b766af8d9065981d315c83a0cc26cedc2026bb28f8e1419f2988c21a4d86ab5442b05c413f38bf7584f1ad4","href":"https://static.observableusercontent.com/files/124b5d268e329cd4ae11af83cb4a4f181a51246f5b766af8d9065981d315c83a0cc26cedc2026bb28f8e1419f2988c21a4d86ab5442b05c413f38bf7584f1ad4","name":"O-Net B_Occupations SOC-Related (2021-06-10).csv","type":"text/csv","lastModified":1623367692678.714,"size":300089},{"id":"64eecd40e51e8f508c1e953389221bef640f77eb048af35c98e92acab19a0c810a4cd4a1e6efe65a675a8e0ed0168e0cd027e66e09a2511f811573c8ea6e1e37","href":"https://static.observableusercontent.com/files/64eecd40e51e8f508c1e953389221bef640f77eb048af35c98e92acab19a0c810a4cd4a1e6efe65a675a8e0ed0168e0cd027e66e09a2511f811573c8ea6e1e37","name":"O-Net C_Skill-Occupation with Metrics (2021-06-10).csv","type":"text/csv","lastModified":1623368724017.449,"size":7536239},{"id":"f840a66b14a96096ef76d76dbedacb62787782f3b26a0a24445f71f55b98ee46ad42b4ec3ca663235b9791d09ff3475b864fe2c067bf3857b8ed62655cd42609","href":"https://static.observableusercontent.com/files/f840a66b14a96096ef76d76dbedacb62787782f3b26a0a24445f71f55b98ee46ad42b4ec3ca663235b9791d09ff3475b864fe2c067bf3857b8ed62655cd42609","name":"O-Net D_Skills_TreeOnto (2021-06-10).csv","type":"text/csv","lastModified":1623416218781.679,"size":6278},{"id":"5619e82139e5ff73ffe3908ec642dc04954c42d8b63a826f9453d86ae6d892c0217e944155c8793674e3f50456fbf4004bd4b8a5df80bd34dc08c35f0aa1e8b2","href":"https://static.observableusercontent.com/files/5619e82139e5ff73ffe3908ec642dc04954c42d8b63a826f9453d86ae6d892c0217e944155c8793674e3f50456fbf4004bd4b8a5df80bd34dc08c35f0aa1e8b2","name":"O-Net D_Skills Master (2021-06-25)@1.csv","type":"text/csv","lastModified":1624665986445.702,"size":2389},{"id":"bfb7a5b7f31bf90f89358404a0323f7de7e3f2c4efde60826e4fd9d666908a87ccaa4b7a9422aef4c0328ecaa3c3cbc9e6f63058902ea0970c146913c6393894","href":"https://static.observableusercontent.com/files/bfb7a5b7f31bf90f89358404a0323f7de7e3f2c4efde60826e4fd9d666908a87ccaa4b7a9422aef4c0328ecaa3c3cbc9e6f63058902ea0970c146913c6393894","name":"O-Net B_Occupations SOC-Related (2021-06-25).csv","type":"text/csv","lastModified":1624638025322.91,"size":299092}] 2f:{"id":"5c207557dc06587c","slug":"o-net-skills-occupation-matrix","title":"O*Net Skills-Occupation Matrix","thumbnail":"b52254de92386aa002f984ddbf502e688aa9e8315752410bc96f7095ace3788e","access_level":"public","create_time":"$D2021-05-29T13:11:10.391Z","update_time":"$D2021-07-15T02:03:59.673Z","view_time":null,"first_public_time":"$D2021-06-03T16:10:16.079Z","fork":false,"stars":1,"starred":false,"owner":{"type":"team","id":"71cc4b7b7d5d9d3b","login":"smithgit","name":"Sam Smith","avatar_url":"https://avatars-next.observableusercontent.com/9229a195929241600a72ca6611a13cdd6eb5c2c3a833ed1f921e2ad7cf4ffbd8","tier":"starter_2024"},"version":1866,"publish_version":null,"role":null,"authored":false,"authors":[{"type":"individual","id":"06b4cf3da6c516bf","login":"smithgit","name":"Sam Smith","avatar_url":"https://avatars-next.observableusercontent.com/9229a195929241600a72ca6611a13cdd6eb5c2c3a833ed1f921e2ad7cf4ffbd8","tier":null}],"members":[{"type":"individual","id":"06b4cf3da6c516bf","login":"smithgit","name":"Sam Smith","avatar_url":"https://avatars-next.observableusercontent.com/9229a195929241600a72ca6611a13cdd6eb5c2c3a833ed1f921e2ad7cf4ffbd8","tier":null,"role":"editor"}],"comments":[],"custom_thumbnail":false,"trashed":false,"subscribed":null,"forks":1,"collection":null,"type":"notebook","body":{"title":"O*Net Skills-Occupation Matrix","cells":[{"id":0,"value":"# O*Net Skills-Occupation Matrix \n## Occupations by Proposed Ontological Group along x-axis and skills by group along y-axis \n\n\n\n\n","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":812,"value":"$31","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":833,"value":"### You have selected: \n Type: **${obsSelType}** \nOccupation Sequence: **${obsOccupSeq}** \nSkill Sequence: **${obsSkillSeq}** \nShowing **${obsArSelOccupIds.length}** of ${Object.entries(dict_Occup).length} Occupations beginning with zzz","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":821,"value":"viewof obsSelType= Inputs.radio([\"Ref-200\", \"Modulo-4, 0\", \"Modulo-4, 2\", \"Info\", \"People\", \"Produce\", \"Process\"],\n {label: \"Selection Type: \", value: \"Ref-200\"})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":825,"value":"viewof obsOccupSeq = Inputs.radio([\"Major O*Net Group\", \"OccO Onto Group\", \"Random\"],\n {label: \"Occupation Sequence: \", value: \"Major O*Net Group\"})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":851,"value":"viewof obsSkillSeq = Inputs.radio([\"O*Net Sequence\", \"Skill Onto Group\"],\n {label: \"Skill Sequence: \", value: \"O*Net Sequence\"})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1842,"value":"$32","pinned":true,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":1261,"value":"obscfg.widthMax < width ? obscfg.widthMax : width","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1366,"value":"// cell: use slider control for now to move mainGroup\n// base x translation on % of slider amt; slider 100% = width of displayed occups / width of\n// all selected occup displayed; no slider if all selected are displayed\nviewof sliderPctDisp = Inputs.range([1, obsArSelOccupIds.length], {step: 1, \n value: width/obscfg.pxHor, label: \"Occupation Display Range: \"})\n//viewof = Inputs.range(1, obsArSelOccupIds.length, {value: width / obscfg.pxHor, label: \n // \"Occuption Diplay Range: \"})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1350,"value":"tmpShift = (200 - sliderPctDisp) - 52 ","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1352,"value":"tmpWbyHor = width/obscfg.pxHor","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1176,"value":"$33","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1170,"value":"function sliderClick(event, d) {\n console.log(\"slider clicked \" + event.x)\n d3.select(\"#slider\")\n .attr(\"x\", 120)\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":804,"value":"obsMessage = \"Any old message here!\"","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":25,"value":"$34","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":372,"value":"dictOccupSkills","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":85,"value":"$35","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":702,"value":"// cell: Class to display tooltip\n// from: https://observablehq.com/@clhenrick/tooltip-component\nimport { Tooltip } from \"@clhenrick/tooltip-component\"","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":709,"value":"obsStatsBySkill = fnCalcStatsBySkill()","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":179,"value":"$36","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":715,"value":"obsStatsByOccup = fnCalcStatsByOccup()","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":650,"value":"$37","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1484,"value":"$38","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":11,"value":"// cell: Select by indicated modulo-3 value of 0, 1, 2; sort by seqOntoGrp\nfunction fnGetOccupMod4(val) {\n let idx = 1 // starting with 1 not zero\n let arOccup = []\n data_Occup.forEach((occup) => {\n const mod4 = idx % 4\n if (mod4 === val) { // NOTE converstion to integer!\n const obj = {seqOntoGrp: parseInt(occup.SeqOntoGrp), SOC_Code: occup.SOC_Code}\n arOccup.push(obj)\n }\n idx += 1\n })\n // array slice will generate a new array object:\n // sorting in d3: https://observablehq.com/@d3/d3-ascending\n return arOccup.slice().sort((a, b) => d3.ascending(a.seqOntoGrp, b.seqOntoGrp))\n} ","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1221,"value":"$39","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":978,"value":"$3a","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1035,"value":"// cell: test\nfnGetPoints(\"11-1011.00\")","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":951,"value":"$3b","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":282,"value":"// cell: Read through occupations and see how occupations fall into major groups and sub-groups\nfunction fnOccupAnalyze(majGrpId) {\n let numByMajGrp = {}\n let numOccup = 0\n let result = [] \n data_Occup.forEach((occup, i) => {\n numOccup += 1\n const myMaj = occup.MajGrp.substring(0,2)\n if (i < 3) console.log(\"mj \" + myMaj) \n\n if (majGrpId === \"00\") {\n if (! numByMajGrp.hasOwnProperty(myMaj)) {\n numByMajGrp[myMaj] = 0\n }\n numByMajGrp[myMaj] += 1\n } else {\n\n }\n })\n\n let sumInResult = 0\n for (const [key, val] of Object.entries(numByMajGrp) ) {\n // console.log(\"key \" + key + \" \" + val)\n // later display as table!\n sumInResult += val\n }\n console.log(\"Res: tot: \" + numOccup + \" sum: \" + sumInResult + \" obj: \", numByMajGrp)\n return numByMajGrp\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1407,"value":"$3c","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":964,"value":"$3d","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":860,"value":"// cell: get skills list with O*Net and Onto sequence Idx \n// 2021-06-10 first use; note skip if no ONetSeqIdx as some rows are headers\ndata_Skills = {\n let mySkills = []\n // cell: get skill-occup file as JS Object -- used several places and cannot do Fileattach in fn?\n let rawSkills = await FileAttachment(\n \"O-Net D_Skills Master (2021-06-25)@1.csv\" \n ).csv(); \n rawSkills.forEach(row => {\n if (row.SkillOntoIdx != \"\") {\n console.log(\"towxxxx \", row)\n mySkills.push({\n skillONetIdx: row.Skill_Index,\n skillId: row.Skill_Id,\n skillName: row.Skill_Name,\n skillONetGrp: row.ONet_Skill_Group,\n skillOntoIdx: row.SkillOntoIdx, // note no skill onto grp code or description\n // added elements:\n count: 0,\n sum: 0,\n avg: 0,\n stddev: 0,\n })\n }\n })\n return mySkills\n}\n","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":314,"value":"// cell: get skill-occup file as JS Object -- used several places and cannot do Fileattach in fn?\ndata_SkillOccup = await FileAttachment(\n \"O-Net C_Skill-Occupation with Metrics (2021-06-10).csv\" // \"Obs Viz Skill-Occup_RND (2021-05-19)-1.csv\"\n ).csv(); ","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":323,"value":"fnSkillsOccupAnalyze()","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":303,"value":"$3e","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1509,"value":"$3f","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1663,"value":"$40","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1678,"value":"fnCalcEntMajGrpSkills(\"ONet\")\n","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1792,"value":"fnCalcEntMajGrpSkills(\"Random\")","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1795,"value":"$41","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1834,"value":"obsResultsAggregate = {\n const resONet = fnCalcEntMajGrpSkills(\"ONet\")\n const resRand = fnCalcEntMajGrpSkills(\"Random\")\n let sumForSkill5ONetIm = 0\n let sumForSkill5RandIm = 0\n let sumForSkillsONetIm = 0\n let sumForSkillsRandIm = 0\n for (let grpnum = 0; grpnum < resONet.length; grpnum++) {\n for (let skillnum = 1; skillnum < 36; skillnum++) {\n if (skillnum === 5) {\n sumForSkill5ONetIm += resONet[grpnum][skillnum]\n sumForSkill5RandIm += resRand[grpnum][skillnum]\n }\n sumForSkillsONetIm += resONet[grpnum][skillnum]\n sumForSkillsRandIm += resRand[grpnum][skillnum] \n }\n \n }\n return { ONet: Math.round(sumForSkillsONetIm * 100)/100, Rand: Math.round(sumForSkillsRandIm * 100)/100 }\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1831,"value":"$42","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1824,"value":"// *** REDO / DELETE this just get sum: \n// cell: function to process output of fnCalcEntMajGrpSkills (whether ONet or Random) and return \n// input: array of groups with each group having 36 skill entropy values\n// Returns: array of occup groups with a total entity for all skills \nfunction fnCalcEntMajGrps(entMajGrpSkills) {\n // First step is get aggregate entropy across all skills\n let entForMajGrps = [] // results\n let priorSkillEnt = 0\n const numGrps = entMajGrpSkills.length\n for (let grpnum = 0; grpnum < numGrps; grpnum++) {\n if (grpnum > 0) {\n for (let skillnum = 0; skillnum < 36; skillnum++) {\n // sum of squares diff from prior group\n entForMajGrps[grpnum] += Math.pow(entMajGrpSkills[skillnum] - priorSkillEnt, 2)\n } \n priorSkillEnt = entMajGrpSkills[skillnum]\n }\n // get sqrt of avg of 22 groups considering there are 21 differences (resOnet\n entForMajGrps[grpnum] = Math.pow(entForMajGrps[grpnum] / (numGrps - 1))\n }\n return entForMajGrps\n}\n\n","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1669,"value":"$43","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":7,"value":"$44","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":923,"value":"// data_Occup = await FileAttachment(\"O-Net B_Occupations SOC-Related (2021-06-25).csv\").csv()\ndata_Occup = await FileAttachment(\"O-Net B_Occupations SOC-Related (2021-07-14).csv\").csv()","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1556,"value":"$45","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":6,"value":"$46","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":4,"value":"d3 = require(\"d3@6\")","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1247,"value":"$47","pinned":true,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"}],"files":"$W48","stdlib":"1","titling":"auto"}} 30:"$2f:body"