Package 'SGP'

Description

SGP contains classes and functions to calculate student growth percentiles and percentile growth projections/trajectories following methodology found in Betebenner (2008, 2009). The package contains two primary functions, studentGrowthPercentiles and studentGrowthProjections, and numerous higher level functions that make use of them including: prepareSGP, analyzeSGP, combineSGP, summarizeSGP, visualizeSGP and outputSGP. These functions are used to calculate and visualize student growth percentiles and percentile growth projections/trajectories for students using large scale, longitudinal assessment data. These norm- and criterion-referenced growth values are currently used in a number of states for many purposes including diagnostic and accountability. The functions employ quantile regression (using the quantreg package) to estimate the conditional density for current achievement using each student's achievement history. Percentile growth projections/trajectories are calculated using the coefficient matrices derived from the student growth percentile analyses. These quantities are summarized in a variety of ways to describe student growth. Beginning with version 1.4-0.0, the SGP package also calculate time dependent SGPs (SGPt) and allows for student growth projections to be calculated across assessment transitions by equating the two tests.

Details

Calculation of student growth percentiles and percentile growth trajectories/projections is typically performed by grade and subject. Data for growth percentile calculation must be specifically formatted. See sgpData for an example data set. Batch R syntax for performing analyses across all grades and years is provided in the examples of the studentGrowthPercentiles and studentGrowthProjections using the higher level functions prepareSGP, analyzeSGP, combineSGP, summarizeSGP, and visualizeSGP.

Author(s)

Damian W. Betebenner [email protected], Adam Van Iwaarden [email protected], Ben Domingue [email protected] and Yi Shang [email protected]

References

Betebenner, D. W. (2008). Toward a normative understanding of student growth. In K. E. Ryan & L. A. Shepard (Eds.), The Future of Test Based Accountability (pp. 155-170). New York: Routledge.

Betebenner, D. W. (2009). Norm- and criterion-referenced student growth. Educational Measurement: Issues and Practice, 28(4):42-51.

Betebenner, D. W. (2012). Growth, standards, and accountability. In G. J. Cizek, Setting Performance Standards: Foundations, Methods & Innovations. 2nd Edition (pp. 439-450). New York: Routledge.

Castellano, K. E. & McCaffrey, D. F. (2017). The Accuracy of Aggregate Student Growth Percentiles as Indicators of Educator Performance. Educational Measurement: Issues and Practice, 36(1):14-27.

Koenker, R. (2005). Quantile regression. Cambridge: Cambridge University Press.

Shang, Y., VanIwaarden, A., & Betebenner, D. W. (2015). Covariate measurement error correction for Student Growth Percentiles using the SIMEX method. Educational Measurement: Issues and Practice, 34(1):4-14.

Description

Utility function to perform sequence of 6 steps going from data preparation, prepareSGP, SGP data analysis, analyzeSGP, data combining, combineSGP, data summary, summarizeSGP, data visualization visualizeSGP and data output outputSGP.

Usage

abcSGP(sgp_object,
	state=NULL,
	steps=c("prepareSGP", "analyzeSGP", "combineSGP",
		"summarizeSGP", "visualizeSGP", "outputSGP"),
	years=NULL,
	content_areas=NULL,
	grades=NULL,
	prepareSGP.var.names=NULL,
	prepareSGP.create.additional.variables=FALSE,
  prepareSGP.create.achievement.level=TRUE,
	sgp.percentiles=TRUE,
	sgp.projections=TRUE,
	sgp.projections.lagged=TRUE,
	sgp.percentiles.baseline=TRUE,
	sgp.projections.baseline=TRUE,
	sgp.projections.lagged.baseline=TRUE,
	sgp.use.my.coefficient.matrices=NULL,
	sgp.minimum.default.panel.years=NULL,
	sgp.target.scale.scores=FALSE,
	sgp.target.scale.scores.only=FALSE,
	sgp.test.cohort.size=NULL,
	return.sgp.test.results=FALSE,
	simulate.sgps=TRUE,
	calculate.simex=NULL,
	calculate.simex.baseline=NULL,
    calculate.srs=NULL,
    calculate.srs.baseline=NULL,
	goodness.of.fit.print=TRUE,
	parallel.config=NULL,
	save.intermediate.results=FALSE,
	save.old.summaries=FALSE,
	sgPlot.demo.report=FALSE,
	sgp.config=NULL,
	sgp.summaries=NULL,
	summary.groups=NULL,
	data_supplementary=NULL,
	confidence.interval.groups=NULL,
	plot.types=c("bubblePlot", "studentGrowthPlot", "growthAchievementPlot"),
	outputSGP.output.type=c("LONG_Data",
				"LONG_FINAL_YEAR_Data",
				"WIDE_Data",
				"INSTRUCTOR_Data"),
	outputSGP.directory="Data",
  verbose.output=FALSE,
	sgp.sqlite=FALSE,
	sgp.percentiles.equated=NULL,
    sgp.percentiles.equating.method=NULL,
	sgp.percentiles.calculate.sgps=TRUE,
    get.cohort.data.info=FALSE,
	SGPt=NULL,
  fix.duplicates=NULL)

Arguments

Value

Function returns a list containing the input long data set in the @Data slot as a data.table keyed using VALID_CASE, CONTENT_AREA, YEAR, ID, SGP results including student growth percentile and student growth projections/trajectories in the SGP slot, and summary results in the @Summary slot.

Author(s)

Damian W. Betebenner [email protected] and Adam Van Iwaarden [email protected]

See Also

prepareSGP, analyzeSGP, combineSGP, summarizeSGP,
studentGrowthPercentiles, and studentGrowthProjections

Examples

## Not run: 
## Runs all 5 steps

Demonstration_SGP <- abcSGP(sgp_object=sgpData_LONG, state="DEMO")


## Or letting the function detect the state.

Demonstration_SGP <- abcSGP(sgpData_LONG)


###
###  Example uses of the parallel.config argument
###

Demonstration_SGP <- abcSGP(sgpData_LONG,
	parallel.config=list(
            BACKEND="PARALLEL", TYPE="PSOCK",
            WORKERS=list(
               PERCENTILES=8, BASELINE_PERCENTILES=8, PROJECTIONS=7, LAGGED_PROJECTIONS=6,
               SUMMARY=8,
               GA_PLOTS=8, SG_PLOTS=8)
	)
)


## End(Not run)

Description

Wrapper function used to produce student growth percentiles and student growth projections (both cohort and baseline referenced) using long formatted data like that provided by prepareSGP.

Usage

analyzeSGP(sgp_object,
         state=NULL,
         years=NULL,
         content_areas=NULL,
         grades=NULL,
         sgp.percentiles=TRUE,
         sgp.projections=TRUE,
         sgp.projections.lagged=TRUE,
         sgp.percentiles.baseline=TRUE,
         sgp.projections.baseline=TRUE,
         sgp.projections.lagged.baseline=TRUE,
         sgp.percentiles.baseline.max.order=3,
         sgp.percentiles.srs.baseline.max.order=3,
         sgp.projections.baseline.max.order=3,
         sgp.projections.lagged.baseline.max.order=3,
         sgp.projections.max.forward.progression.years=3,
         sgp.projections.max.forward.progression.grade=NULL,
         sgp.projections.use.only.complete.matrices=NULL,
         sgp.minimum.default.panel.years=NULL,
         sgp.use.my.coefficient.matrices=NULL,
         sgp.use.my.sgp_object.baseline.coefficient.matrices=NULL,
         sgp.test.cohort.size=NULL,
         return.sgp.test.results=FALSE,
         simulate.sgps=TRUE,
         calculate.simex=NULL,
         calculate.simex.baseline=NULL,
         calculate.simex.srs.baseline=NULL,
         calculate.srs=NULL,
         calculate.srs.baseline=NULL,
         goodness.of.fit.print=TRUE,
         sgp.config=NULL,
         sgp.config.drop.nonsequential.grade.progression.variables=TRUE,
         sgp.baseline.panel.years=NULL,
         sgp.baseline.config=NULL,
         trim.sgp.config=TRUE,
         parallel.config=NULL,
         verbose.output=FALSE,
         print.other.gp=NULL,
         sgp.projections.projection.unit="YEAR",
         get.cohort.data.info=FALSE,
         sgp.sqlite=FALSE,
         sgp.percentiles.equated=NULL,
         sgp.percentiles.equating.method=NULL,
         sgp.percentiles.calculate.sgps=TRUE,
         SGPt=NULL,
         fix.duplicates=NULL,
         ...)

Arguments

Value

Function returns a list containing the long data set in the @Data slot as a data.table keyed using VALID_CASE, CONTENT_AREA, YEAR, ID and the student growth percentile and/or student growth projection/trajectory results in the SGP slot.

Author(s)

Damian W. Betebenner [email protected] and Adam Van Iwaarden [email protected]

See Also

prepareSGP, combineSGP

Examples

## Not run: 
## analyzeSGP is Step 2 of 5 of abcSGP
Demonstration_SGP <- sgpData_LONG
Demonstration_SGP <- prepareSGP(Demonstration_SGP)
Demonstration_SGP <- analyzeSGP(Demonstration_SGP)

## Or (explicitly pass state argument)

Demonstration_SGP <- prepareSGP(sgpData_LONG)
Demonstration_SGP <- analyzeSGP(Demonstration_SGP, state="DEMO")

###
###  Example uses of the sgp.config argument
###

#  Use only 3 years of Data, for grades 3 to 6
#  and only perform analyses for most recent year (2012)

my.custom.config <- list(
MATHEMATICS.2013_2014 = list(
	sgp.content.areas=rep("MATHEMATICS", 3), # Note, must be same length as sgp.panel.years
	sgp.panel.years=c('2011_2012', '2012_2013', '2013_2014'),
	sgp.grade.sequences=list(3:4, 3:5, 4:6)),
READING.2013_2014 = list(
	sgp.content.areas=rep("READING", 3),
	sgp.panel.years=c('2011_2012', '2012_2013', '2013_2014'),
	sgp.grade.sequences=list(3:4, 3:5, 4:6)))

Demonstration_SGP <- prepareSGP(sgpData_LONG)
Demonstration_SGP <- analyzeSGP(Demonstration_SGP,
	sgp.config=my.custom.config,
	sgp.percentiles.baseline = FALSE,
	sgp.projections.baseline = FALSE,
	sgp.projections.lagged.baseline = FALSE,
	simulate.sgps=FALSE)


##  Another example sgp.config list:

#  Use different CONTENT_AREA priors, and only 1 year of prior data
my.custom.config <- list(
MATHEMATICS.2013_2014.READ_PRIOR = list(
	sgp.content.areas=c("READING", "MATHEMATICS"),
	sgp.panel.years=c('2012_2013', '2013_2014'),
	sgp.grade.sequences=list(3:4, 4:5, 5:6)),
READING.2013_2014.MATH_PRIOR = list(
	sgp.content.areas=c("MATHEMATICS", "READING"),
	sgp.panel.years=c('2012_2013', '2013_2014'),
	sgp.grade.sequences=list(3:4, 4:5, 5:6)))


## An example showing multiple priors within a single year

Demonstration_SGP <- prepareSGP(sgpData_LONG)

DEMO.config <- list(
READING.2012_2013 = list(
	sgp.content.areas=c("MATHEMATICS", "READING", "MATHEMATICS", "READING", "READING"),
	sgp.panel.years=c('2010_2011', '2010_2011', '2011_2012', '2011_2012', '2012_2013'),
	sgp.grade.sequences=list(c(3,3,4,4,5), c(4,4,5,5,6), c(5,5,6,6,7), c(6,6,7,7,8))),
MATHEMATICS.2012_2013 = list(
	sgp.content.areas=c("READING", "MATHEMATICS", "READING", "MATHEMATICS", "MATHEMATICS"),
	sgp.panel.years=c('2010_2011', '2010_2011', '2011_2012', '2011_2012', '2012_2013'),
	sgp.grade.sequences=list(c(3,3,4,4,5), c(4,4,5,5,6), c(5,5,6,6,7), c(6,6,7,7,8))))

Demonstration_SGP <- analyzeSGP(
		Demonstration_SGP,
		sgp.config=DEMO.config,
		sgp.projections=FALSE,
		sgp.projections.lagged=FALSE,
		sgp.percentiles.baseline=FALSE,
		sgp.projections.baseline=FALSE,
		sgp.projections.lagged.baseline=FALSE,
		sgp.config.drop.nonsequential.grade.progression.variables=FALSE)


###
###  Example uses of the parallel.config argument
###

##  Windows users must use a snow socket cluster:
#  possibly a quad core machine with low RAM Memory
#  4 workers for percentiles, 2 workers for projections.
#  Note the PSOCK type cluster is used for single machines.

Demonstration_SGP <- prepareSGP(sgpData_LONG)
Demonstration_SGP <- analyzeSGP(Demonstration_SGP,
	parallel.config=list(
		BACKEND="PARALLEL", TYPE="PSOCK",
		WORKERS=list(PERCENTILES=4,
                    PROJECTIONS=2,
                    LAGGED_PROJECTIONS=2,
                    BASELINE_PERCENTILES=4))

##  New parallel package - only available with R 2.13 or newer
#  Note there are up to 16 workers, and MPI is used,
#  suggesting this example is for a HPC cluster, possibly Windows OS.
	...
	parallel.config=list(
		BACKEND="PARALLEL", TYPE="MPI",
		WORKERS=list(PERCENTILES=16,
                    PROJECTIONS=8,
                    LAGGED_PROJECTIONS=6,
                    BASELINE_PERCENTILES=12))
	...

## FOREACH use cases:
	...
	parallel.config=list(
		BACKEND="FOREACH", TYPE="doParallel",
		WORKERS=3)
	...


#  NOTE:  This list of parallel.config specifications is NOT exhaustive.
#  See examples in analyzeSGP documentation for some others.0

###
###  Advanced Example: restrict years, recalculate baseline SGP
###  coefficient matrices, and use parallel processing
###

#  Remove existing DEMO baseline coefficient matrices from
#  the SGPstateData object so that new ones will be computed.

SGPstateData$DEMO$Baseline_splineMatrix <- NULL

#  set up a customized sgp.config list

	. . .

#  set up a customized sgp.baseline.config list

	. . .

#  to be completed


## End(Not run)

Description

Utility function/exemplar used to produce student growth percentiles using long formatted data like that provided by prepareSGP. Used as part of analyzeSGP for baseline referenced student growth percentile analyses.

Usage

baselineSGP(sgp_object,
        state=NULL,
        years=NULL,
        content_areas=NULL,
        grades=NULL,
        exclude.years=NULL,
        sgp.config=NULL,
        sgp.baseline.config=NULL,
        sgp.baseline.panel.years=NULL,
        sgp.percentiles.baseline.max.order=3,
        return.matrices.only=FALSE,
        calculate.baseline.sgps=TRUE,
        calculate.simex.baseline=NULL,
        goodness.of.fit.print=TRUE,
        parallel.config=NULL,
        SGPt=NULL,
	...)

Arguments

Value

If return.matrices.only is set to TRUE function returns a list containing the baseline referenced coefficient matrices. Otherwise function returns the SGP object provided with the sgp_object argument with the baseline referenced coefficient matrices, growth percentiles, etc. embedded.

Author(s)

Adam Van Iwaarden [email protected], Ben Domingue [email protected] and Damian W. Betebenner [email protected]

See Also

prepareSGP, analyzeSGP, combineSGP

Examples

## Not run: 
##  Calculate baseline referenced SGPs
## (using coefficient matrices embedded in SGPstateData)

Demonstration_SGP <- prepareSGP(sgpData_LONG)
Demonstration_SGP <-  baselineSGP(Demonstration_SGP)


## Calculate baseline referenced coefficient matrices

SGPstateData[["DEMO"]][["Baseline_splineMatrix"]] <- NULL
Demonstration_SGP <- prepareSGP(sgpData_LONG)
DEMO_Baseline_Matrices <- baselineSGP(
				Demonstration_SGP,
				return.matrices.only=TRUE,
				calculate.baseline.sgps=FALSE)


## Calculate baseline referenced coefficient matrices and
## baseline referenced SGPs with 4 years of data

SGPstateData[["DEMO"]][["Baseline_splineMatrix"]] <- NULL

sgpData_LONG_4_YEAR <- subset(sgpData_LONG, YEAR!="2013_2014")

Demonstration_SGP <- prepareSGP(sgpData_LONG_4_YEAR)
Demonstration_SGP <- baselineSGP(Demonstration_SGP)

## End(Not run)

Description

Function to create bubble plots associated with student growth percentile and percentile growth trajectory results. The function is adaptable to many representations but is used in conjunction with results derived from summarizeSGP to represent summary level results of growth against achievement (usually, median student growth percentile against percentage at/above proficient). The function has MANY options and users are advised to read this documentation thoroughly as well as investigate the source code for the function itself to see what the many different representations that are possible. The function has the ability to produce interactive data tips using the pdf2 package available on R-Forge. This package is NOT installed as part of the SGP package and must be installed separately from the package to take advantage of this functionality of the bubblePlot function. To install pdf2 from the R prompt type: install.packages("pdf2",repos="http://R-Forge.R-project.org"). The use of the pdf2 package is scheduled to be deprecated as it is no longer maintained by the creator and requires use of a pre 2.14 version of R.

Usage

bubblePlot(
	bubble_plot_data.X,
	bubble_plot_data.Y,
	bubble_plot_data.SUBSET=NULL,
	bubble_plot_data.INDICATE=NULL,
        bubble_plot_data.BUBBLE_CENTER_LABEL=NULL,
	bubble_plot_data.SIZE,
	bubble_plot_data.LEVELS=NULL,
	bubble_plot_data.BUBBLE_TIPS_LINES,
	bubble_plot_labels.X=c("Growth", "Median Student Growth Percentile"),
	bubble_plot_labels.Y=c("Achievement", "Percent at/above Proficient"),
	bubble_plot_labels.SIZE=c(50, 100, 500, 1000),
	bubble_plot_labels.LEVELS=NULL,
	bubble_plot_labels.BUBBLE_TIPS_LINES=list("Median SGP (Count)",
		"Percent at/above Proficient"),
	bubble_plot_labels.BUBBLE_TITLES,
	bubble_plot_titles.MAIN="Growth and Achievement",
	bubble_plot_titles.SUB1="State School Performance",
	bubble_plot_titles.SUB2="Growth & Current Achievement",
	bubble_plot_titles.LEGEND1="School Size",
	bubble_plot_titles.LEGEND2_P1=NULL,
	bubble_plot_titles.LEGEND2_P2=NULL,
	bubble_plot_titles.NOTE=NULL,
	bubble_plot_configs.BUBBLE_MIN_MAX=c(0.03, 0.03),
	bubble_plot_configs.BUBBLE_X_TICKS=seq(0,100,10),
	bubble_plot_configs.BUBBLE_X_TICKS_SIZE=c(rep(0.6, 5), 1, rep(0.6, 5)),
        bubble_plot_configs.BUBBLE_X_BANDS=NULL,
        bubble_plot_configs.BUBBLE_X_BAND_LABELS=NULL,
	bubble_plot_configs.BUBBLE_Y_TICKS=seq(0,100,10),
	bubble_plot_configs.BUBBLE_Y_TICKS_SIZE=rep(0.6, 11),
        bubble_plot_configs.BUBBLE_Y_BANDS=NULL,
        bubble_plot_configs.BUBBLE_Y_BAND_LABELS=NULL,
	bubble_plot_configs.BUBBLE_SUBSET_INCREASE=0,
	bubble_plot_configs.BUBBLE_SUBSET_ALPHA=list(Transparent=0.3, Opaque=0.95),
	bubble_plot_configs.BUBBLE_COLOR="deeppink2",
        bubble_plot_configs.BUBBLE_COLOR_GRADIENT_REVERSE=FALSE,
	bubble_plot_configs.BUBBLE_TIPS=TRUE,
	bubble_plot_configs.BUBBLE_PLOT_DEVICE="PDF",
	bubble_plot_configs.BUBBLE_PLOT_FORMAT="print",
	bubble_plot_configs.BUBBLE_PLOT_LEGEND=FALSE,
	bubble_plot_configs.BUBBLE_PLOT_TITLE=TRUE,
	bubble_plot_configs.BUBBLE_PLOT_SUMMARY_STATISTICS=TRUE,
	bubble_plot_configs.BUBBLE_PLOT_BACKGROUND_LABELS=c("Growth", "Achievement"),
	bubble_plot_configs.BUBBLE_PLOT_EXTRAS="BASE_LINE",
        bubble_plot_configs.BUBBLE_PLOT_DIMENSION=NULL, ## List of WIDTH and HEIGHT
	bubble_plot_configs.BUBBLE_PLOT_NAME="bubblePlot.pdf",
	bubble_plot_configs.BUBBLE_PLOT_PATH="Figures",
	bubble_plot_pdftk.CREATE_CATALOG=FALSE)

Arguments

Details

Typical use of the function is as part of visualizeSGP function. However, function can be used more generically for diverse plots showing many dimensions of data simultaneously.

Value

Function creates a bubble chart and writes the result as a PDF to bubble_plot_configs.BUBBLE_PATH.

Author(s)

Damian W. Betebenner [email protected]

Description

Function includes a number of "styles" associated with bubblePlot to create bubble plots depicting a variety of relationships often of interest to stakeholders. The bubblePlot function itself is adaptable to many representations but is most often used in conjunction with results derived from summarizeSGP to represent summary level results of growth against achievement (usually, median student growth percentile against percentage at/above proficient).

Usage

bubblePlot_Styles(
                sgp_object,
		state,
		bPlot.years=NULL,
		bPlot.content_areas=NULL,
		bPlot.districts=NULL,
		bPlot.schools=NULL,
		bPlot.instructors=NULL,
		bPlot.styles=c(1),
		bPlot.levels=NULL,
		bPlot.level.cuts=NULL,
		bPlot.full.academic.year=TRUE,
		bPlot.minimum.n=10,
		bPlot.anonymize=FALSE,
		bPlot.prior.achievement=TRUE,
		bPlot.draft=FALSE,
		bPlot.demo=FALSE,
		bPlot.output="PDF",
		bPlot.format="print",
		bPlot.folder="Visualizations/bubblePlots")

Arguments

Details

bubblePlot_Styles is an omnibus function containing a number of applications of the bubblePlot function with data output from SGP analyses. As added styles are constructed they will be added to the function allowing user to construct plots of their liking. User wishing to participate and provide or suggest specific styles of their own should contact the package maintainer. Styles representing summary level data (e.g., growth and achievement for schools) are currently assigned numbers from 1 to 99 and styles representing individual level data (e.g., growth and achievement for students within a single grade) are currently assigned numbers from 100 to 199.

Value

Function produces numerous PDF bubble charts in the styles specified by the function.

Author(s)

Damian W. Betebenner [email protected] and Adam Van Iwaarden [email protected]

Description

The function capwords converts characters to mixed case character as intelligently as possible and leading/trailing spaces.

Usage

capwords(x,
    special.words = c("ELA","I", "II", "III", "IV",  "CCSD", "CUSD", "CUD", "USD", "PSD", 
          "UD", "ESD", "DCYF", "EMH", "HS", "MS", "ES", "SES", "IEP", "ELL", "MAD", 
          "PARCC", "SBAC", "SD", "SWD", "US", "SGP", "SIMEX", "SS", "SAT", "PSAT", 
          "WIDA", "ACCESS", "WIDA-ACCESS"))

Arguments

Value

Returns a mixed case character string.

Author(s)

Damian W. Betebenner [email protected]

Examples

capwords("TEST") ## Test
capwords("TEST1 TEST2") ## Test1 Test2
capwords("O'NEIL") ## O'Neil
capwords("JOHN'S") ## John's

## Use sapply for converting character vectors

test.vector <- paste("TEST", 1:10, sep="")
sapply(test.vector, capwords)


## With factors, convert levels instead of the entire vector

test.factor <- factor(paste("TEST", rep(letters[1:10], each=50)))
levels(test.factor) <- sapply(levels(test.factor), capwords)
levels(test.factor)

Description

Utility function that merges student long data in the @Data slot with results from student growth percentiles and/or student growth projections calculations. Default values of this function are designed to be used following use of other utility functions: prepareSGP and analyzeSGP. Function is integrated with cutscores embedded in SGPstateData to calculate growth-to-standard SGP targets and their associated scale scores with catch-up/keep-up to proficient status and/or move-up/stay-up to advanced status as well as the scale scores associated with these targets.

Usage

combineSGP(sgp_object,
	state=NULL,
	years=NULL,
	content_areas=NULL,
	sgp.percentiles=TRUE,
        sgp.percentiles.baseline=TRUE,
	sgp.projections=TRUE,
	sgp.projections.baseline=TRUE,
	sgp.projections.lagged=TRUE,
        sgp.projections.lagged.baseline=TRUE,
	sgp.target.scale.scores=FALSE,
	sgp.target.scale.scores.only=FALSE,
    sgp.target.scale.scores.merge=FALSE,
	sgp.target.content_areas=NULL,
	max.sgp.target.years.forward=3,
	update.all.years=FALSE,
	sgp.config=NULL,
	sgp.percentiles.equated=NULL,
	SGPt=NULL,
  fix.duplicates=NULL,
	parallel.config=NULL)

Arguments

Value

Function returns a list containing the input long data set in the @Data slot as a data.table keyed using VALID_CASE, CONTENT_AREA, YEAR, ID merged with student growth percentiles and/or straight/lagged projection targets and catch-up/keep-up and move-up/stay-up status with, if requested, the scale scores associated with such targets.

Author(s)

Damian W. Betebenner [email protected] and Adam Van Iwaarden [email protected]

See Also

prepareSGP, analyzeSGP

Examples

## Not run: 
## combineSGP is Step 3 of 5 of abcSGP
Demonstration_SGP <- sgpData_LONG
Demonstration_SGP <- prepareSGP(Demonstration_SGP)
Demonstration_SGP <- analyzeSGP(Demonstration_SGP)
Demonstration_SGP <- combineSGP(Demonstration_SGP)

## End(Not run)

Description

Utility function used to analyze supplied long data or an existing SGP class object to identify potential course progressions suitable for analysis with analyzeSGP, studentGrowthPercentiles, etc. See examples for more information.

Usage

courseProgressionSGP(
	sgp_object,
	lag.direction=c("FORWARD", "BACKWARD"),
	year)

Arguments

Value

Function returns a nested list class object. The final node of each nested list is a data.table which summarizes the number of students with a particular GRADE by CONTENT_AREA by YEAR course progression

Author(s)

Adam Van Iwaarden [email protected] and Damian W. Betebenner [email protected]

See Also

sgpData_LONG

Examples

## Not run: 
## Run courseProgressionSGP on the subset of the long data that contains
## ONLY mathematics related records (would realistically also contain EOCT math courses)
Math_Data <- subset(SGPdata::sgpData_LONG, CONTENT_AREA == "MATHEMATICS")
Math_Progressions <- courseProgressionSGP(Math_Data, lag.direction= "BACKWARD", year="2015_2016")

##  Examine results for Adcademic Year 2015-2016, 5th grade Mathematics.
Math_Progressions[['BACKWARD']][['2015_2016']][['MATHEMATICS.05']]
Math_Progressions[['BACKWARD']][['2015_2016']][['MATHEMATICS.05']][COUNT>100]

## End(Not run)

Description

The function createKnotsBoundaries creates Knots, Boundaries and Loss/Hoss scores for subsequent use and embedding in SGPstateData. Function can be called separately but is usually called as part of prepareSGP. See examples below.

Usage

createKnotsBoundaries(tmp.data,
	 knot.cut.percentiles=c(0.2,0.4,0.6,0.8))

Arguments

Value

Returns a list containing Knots, Boundaries and Loss/Hoss scores.

Author(s)

Damian W. Betebenner [email protected]

Examples

## Not run: 
### Run on supplied long data

DEMO_Knots_Boundaries <- createKnotsBoundaries(sgpData_LONG)

### Run as part of prepareSGP

### First NULL out knots and boundaries embedded in SGPstateData

SGPstateData[["DEMO"]][["Achievement"]][["Knots_Boundaries"]] <- NULL
Demonstration_SGP <- prepareSGP(sgpData_LONG)

## End(Not run)

Description

The function getStateAbbreviation converts state/organization abbreviations to their long form and back. For example ID gets converted to Idaho.

Usage

getStateAbbreviation(
                    supplied.name,
	                SGPfunction=NULL,
	                type="ABBREVIATION")

Arguments

Value

Returns a character string.

Author(s)

Damian W. Betebenner [email protected]

Examples

getStateAbbreviation("IDAHO") ## ID
getStateAbbreviation("ID", type="Long") ## Idaho

Description

The function gofPrint is used to output Goodness of Fit plots from R grobs stored in a SGP object.

Usage

gofPrint(
    sgp_object,
    years = NULL,
    content_areas = NULL,
    grades = NULL,
    sgp_types = NULL,
    norm_group = NULL,
    output_format = c("PDF", "SVG", "DECILE_TABLES"),
    output_path = "Goodness_of_Fit",
    ...)

Arguments

Value

Returns a graphical output of the fit plot(s) requested based on the arguments provided. Can also save the decile table data in Rdata format.

Author(s)

Adam Van Iwaarden [email protected] and Damian W. Betebenner [email protected]

Examples

## Not run: 
    gofPrint(Demonstration_SGP)
  
## End(Not run)

Description

gofSGP creates goodness-of-fit plots in either PDF or PNG for showing SGP distribution by prior achievement level and prior scale score decile. These plots expand upon the plots currently produced with the studentGrowthPercentiles function.

Usage

gofSGP(
	sgp_object,
	state=NULL,
	years=NULL,
	content_areas=NULL,
	content_areas_prior=NULL,
	grades=NULL,
	ceiling.floor=TRUE,
	use.sgp="SGP",
	output.format="PDF",
	color.scale="reds.and.blues")

Arguments

Value

Returns output ('PDF' , 'PNG' or 'SVG') associated with goodness-of-fit analyses.

Author(s)

Damian W. Betebenner [email protected]

See Also

studentGrowthPercentiles

Examples

## Not run: 
Demonstration_SGP <- abcSGP(sgpData_LONG)
gofSGP(Demonstration_SGP)

## End(Not run)

Description

Function to create growth and achievement plots depicting system level results associated with student growth percentile results. The charts show, simultaneously, norm- and criterion-referenced student achievement (i.e., status) as well as norm- and criterion-referenced student growth. These charts are those shown on the cover of the December 2009 Issue of Educational Measurement: Issues and Practice. See Betebenner (2009) and Betebenner (2012) for more details

Usage

growthAchievementPlot(
    gaPlot.sgp_object,
    gaPlot.students=NULL,
    gaPlot.percentile_trajectories,
    gaPlot.achievement_percentiles=c(.01, seq(.05, .95, by=.05), .99),
    gaPlot.show.scale.transformations=TRUE,
    gaPlot.grade_range,
    gaPlot.max.order.for.progression=NULL,
	gaPlot.start.points="Achievement Level Cuts",
    gaPlot.back.extrapolated.cuts=NULL,
	gaPlot.subtitle = TRUE,
    gaPlot.SGPt=NULL,
    state,
    content_area,
    year,
    format="print",
    baseline=FALSE,
    equated=NULL,
	output.format="PDF",
    output.folder,
    assessment.name)

Arguments

Details

Typical use of the function is as part of visualizeSGP function. However, function can be used to produce growth and achievement charts.

Value

Function creates a growth and achievement chart and writes the result as a PDF to output.folder.

Author(s)

Damian W. Betebenner [email protected]

References

Betebenner, D. W. (2012). Growth, standards, and accountability. In G. J. Cizek, Setting Performance Standards: Foundations, Methods & Innovations. 2nd Edition (pp. 439-450). New York: Routledge.

Betebenner, D. W. (2009). Norm- and criterion-referenced student growth. Educational Measurement: Issues and Practice, 28(4):42-51.

Description

Utility function used to export student data and SGP results for a variety of purposes. Current functionality exports data in wide format for data visualization purposes. See source code for detailed functionality.

Usage

outputSGP(sgp_object,
	state=NULL,
        output.type=c("LONG_Data", "LONG_FINAL_YEAR_Data", "WIDE_Data", 
			"INSTRUCTOR_Data"),
        baseline.sgps=FALSE,
        outputSGP_SUMMARY.years=NULL,
        outputSGP_SUMMARY.content_areas=NULL,
        outputSGP_INDIVIDUAL.years=NULL,
        outputSGP_INDIVIDUAL.content_areas=NULL,
        outputSGP.anonymize=FALSE,
        outputSGP.student.groups=NULL,
        outputSGP.directory="Data",
	outputSGP.translate.names=TRUE,
	outputSGP.projection.years.for.target=3,
	outputSGP.pass.through.variables=NULL)

Arguments

Value

Function writes data in multiple formats including .Rdata, .txt (pipe delimited) and zipped versions of .txt.

Author(s)

Damian W. Betebenner [email protected]

See Also

abcSGP, prepareSGP, analyzeSGP, combineSGP, summarizeSGP

Examples

## Not run: 
Demonstration_SGP <- prepareSGP(sgpData_LONG)
Demonstration_SGP <- analyzeSGP(Demonstration_SGP)
Demonstration_SGP <- combineSGP(Demonstration_SGP)
outputSGP(Demonstration_SGP)

## Output current year

outputSGP(Demonstration_SGP, output.type="LONG_FINAL_YEAR_Data")

## End(Not run)

Description

Utility function/exemplar used to embed supplied long data into a list object as a keyed data.table. NOTE: This function also serves the purposes of running many checks on the SGP object you construct to make sure it is up to date and in the best shape possible. If you have an older object that you wish to make sure is up to date with the latest version of the SGP package, running prepareSGP on an object is never bad thing to do. See examples for more information.

Usage

prepareSGP(data,
	data_supplementary=NULL,
	state=NULL,
	var.names=NULL,
	create.additional.variables=TRUE,
	fix.duplicates=NULL,
  create.achievement.level=TRUE)

Arguments

Value

Function returns an object of class SGP. The long data is in the data slot.

Author(s)

Adam Van Iwaarden [email protected], Damian W. Betebenner [email protected], and Ben Domingue [email protected]

See Also

sgpData_LONG

Examples

## Not run: 
## prepareSGP is Step 1 of 5 of abcSGP
Demonstration_SGP <- prepareSGP(sgpData_LONG)

## Running prepareSGP on an already create SGP object as part of a annual update

Demonstration_SGP <- prepareSGP(Demonstration_SGP)


## Running prepareSGP on a long data set without creating addition variables

Demonstration_SGP <- prepareSGP(sgpData_LONG, create.additional.variables=FALSE)

## End(Not run)

Description

rliSGP is a wrapper function design to expedite SGP analyses on Renaissance Learning Incorporated (RLI) interim STAR assessments.

Usage

rliSGP(
	sgp_object,
  additional.data=NULL,
	state=NULL,
	content_areas=c("MATHEMATICS", "MATHEMATICS_SPANISH", "READING", 
			"READING_SPANISH", "READING_UNIFIED", "EARLY_LITERACY", 
			"EARLY_LITERACY_SPANISH"),
  testing.window,
  eow.or.update="UPDATE",
	update.save.shell.only=FALSE,
  configuration.year,
	sgp.percentiles.baseline=TRUE,
	sgp.projections.baseline=TRUE,
	sgp.projections.lagged.baseline=FALSE,
	sgp.target.scale.scores=TRUE,
  update.ids=NULL,
	SGPt=TRUE,
	simulate.sgps=FALSE,
	save.intermediate.results=FALSE,
	coefficient.matrices=NULL,
	goodness.of.fit.print=FALSE,
	return.updated.shell=FALSE,
	fix.duplicates="KEEP.ALL",
	eow.calculate.sgps=FALSE,
	score.type="RASCH",
	cutscore.file.name="Cutscores.csv",
	get.cohort.data.info=FALSE,
  use.latest.rliMatrices=TRUE,
  parallel.config=NULL)

Arguments

Value

Saves relevant results to disc for use in subsequent analyses.

Author(s)

Damian W. Betebenner [email protected]

Examples

## Not run: 
####### For Within Window processing

testSGP('RLI')

####### For End-of-Window processing



## End(Not run)

Function for renaming data (typically from outputSGP) from a state/organization naming conventions to those used in the SGP package

Description

setNamesSGP renames a dataset (without copying or returning the data).

Usage

setNamesSGP(
	data,
	state=NULL)

Arguments

Value

NULL. Simply renames the data. Note that the state must be included in the SGPstateData and have a Variable_Name_Lookup entry to work.

Author(s)

Adam R. Van Iwaarden [email protected]

See Also

outputSGP

Examples

## Not run: 
load("Data/Demonstration_SGP_LONG_Data.Rdata")
setNamesSGP(Demonstration_SGP_LONG_Data)

## End(Not run)

Description

The formal S4 class for SGP. This class stores the data object for use with the functions analyzeSGP, combineSGP, summarizeSGP, and visualizeSGP. The SGP class contains and organizes all the results associated with SGP analyses. is.SGP tests for membership for this class.

Details

list.null:

combines class list and class NULL

Usage

Objects can be created by calls of the form new("SGP", ...), but this is not encouraged. To instantiate a new instance of SGP class use the function prepareSGP instead.

is.SGP(x)

Slots

Data:

A data.table including student-level data in a (long) format. For annual testing, each VALID_CASE, CONTENT_AREA, YEAR, ID combination represents a unique case in the data. For instances with multiple tests within a year, each VALID_CASE, CONTENT_AREA, YEAR, ID, WITHIN_YEAR combination represents a unique case in the data. See sgpData_LONG for an exemplar data set

Data_Supplementary:

A list (possibly NULL) providing additional data.tables containing student level multiple-membership lookup tables. For example, sgpData_INSTRUCTOR_NUMBER provides student teacher linkages and can be embedded in this slot using a list that contains it.

Names:

A data.frame with five columns: 'names.provided', 'names.sgp', 'names.type', 'names.info', 'names.output'. This data.frame is used as a lookup table to translate state specific variable names to SGP variable names as well as provide information for summarizeSGP on the types of summary tables to produce.

SGP:

A list including the output from analyzeSGP

Summary:

A list including the output from summarizeSGP

Version:

A list of meta-data including the version of the SGP package used to construct the SGP object and the date the object was created.

Author(s)

Jonathan P. Weeks [email protected], Adam Van Iwaarden [email protected] and Damian W. Betebenner [email protected]

See Also

prepareSGP

Description

An environment (an object of class environment) containing information on state assessment programs, organized by state. Currently the environment contains achievement level cutscores and labels for the state assessments, assessment name and abbreviation, growth cutscores and labels, information on vertical scaling, conditional standard errors of measurement (CSEMs), knots and boundaries, and state specific configurations currently being used for SGP analyses at the agency (state, district, national) level. The cutscores, in particular, are used to calculate growth-to-standard/projection values. States currently included in the data set are Arizona (AZ), Arkansas (AR), California (CA), Colorado (CO), Connecticut (CT), Georgia (GA), Hawaii (HI), Idaho (ID), Indiana (IN), Kansas (KS), Maine (ME), Massachusetts (MA), Minnesota (MN), Mississippi (MS), Missouri (MO), Nebraska (NE), Nevada (NV), New Hampshire (NH), New Mexico (NM), New Jersey (NJ), New York (NY), Oregon (OR), Rhode Island (RI), South Dakota (SD), Utah (UT), Vermont (VT), Virginia (VA), West Virginia (WV), Wisconsin (WI), Archdioces of Baltimore (AOB), Colorado English Language Assessment (CELA), Demonstration (DEMO), Albuquerque (ABQ), Australia NAPLAN (NAPLAN), Guatemala (GUA), Renaissance Learning Incorporated (RLI), Renaissance Learning Incorporated UK (RLI_UK), and New Haven (NEW_HAVEN).

Author(s)

Damian W. Betebenner [email protected] and Adam Van Iwaarden [email protected]

Source

State assessment data and technical assessment documentation

Description

The formal S4 class for coefficient matrices produced from the studentGrowthPercentiles function. This class stores the B-spline knots and boundaries used by the coefficient matrix object for the production of student growth percentiles and projections.

Details

splineMatrix:

This class contains the S3 matrix class, inheriting its methods. The slot Knots should be one or more lists of numeric vector(s) used in the internal call to bs, which generates a B-spline basis matrix from student scores. There are typically with 4 values for the knots. Similarly, Boundaries are used in bs for the Boundary.knots argument. This is always two values which are at or slightly beyond the lowest and highest observed student scores. Content_Areas and Grade_Progression provide information about the data (sub)set used to produce the matrix.

Objects from the Class

Objects can be created by calls of the form new("splineMatrix", ...), but this is not encouraged. Previously produced coefficient matrices MUST be bound to the IDENTICAL knots and boundaries used to create them. Use the function studentGrowthPercentiles instead.

Slots

.Data:

A coefficient matrix derived from studentGrowthPercentiles.

Knots:

A list(s) of numeric values used as the knots to generate the B-spline basis matrix in studentGrowthPercentiles.

Boundaries:

A list(s) of numeric values used as the Boundary.knotsto generate the B-spline basis matrix in studentGrowthPercentiles.

Content_Areas:

A list of time dependent content area names included in the data used to produce the coefficient matrix.

Grade_Progression:

A list of the time dependent grades included in the data used to produce matrices.

Time:

A list of the Times (e.g., years) measurements occurred included in the data used to produce matrices.

Time_Lags:

A list of the time lags/differences between Time (e.g., years) included in the data used to produce matrices.

Version:

A list including the version of the SGP package used to construct the splineMatrix object and the date the object was created.

Author(s)

Adam Van Iwaarden [email protected], Ben Domingue [email protected] and Damian W. Betebenner [email protected]

See Also

studentGrowthPercentiles

Description

Function to calculate student growth percentiles using large scale assessment data. Outputs growth percentiles for each student and supplies various options as function arguments. Results from this function are utilized to calculate percentile growth projections/trajectories using the
studentGrowthProjections function.

Usage

studentGrowthPercentiles(panel.data,
                         sgp.labels,
                         panel.data.vnames=NULL,
                         additional.vnames.to.return=NULL,
                         grade.progression,
                         content_area.progression,
                         year.progression,
                         year_lags.progression,
                         num.prior,
                         max.order.for.percentile=NULL,
                         return.additional.max.order.sgp=NULL,
                         subset.grade,
                         percentile.cuts,
                         growth.levels,
                         use.my.knots.boundaries,
                         use.my.coefficient.matrices,
                         calculate.confidence.intervals,
                         print.other.gp=FALSE,
                         print.sgp.order=FALSE,
                         calculate.sgps=TRUE,
                         rq.method="br",
                         rq.method.for.large.n="fn",
                         max.n.for.coefficient.matrices=NULL,
                         knot.cut.percentiles=c(0.2,0.4,0.6,0.8),
                         knots.boundaries.by.panel=FALSE,
                         exact.grade.progression.sequence=FALSE,
                         drop.nonsequential.grade.progression.variables=TRUE,
                         convert.0and100=TRUE,
                         sgp.quantiles="Percentiles",
                         sgp.quantiles.labels=NULL,
                         sgp.loss.hoss.adjustment=NULL,
                         sgp.cohort.size=NULL,
                         sgp.less.than.sgp.cohort.size.return=NULL,
                         sgp.test.cohort.size=NULL,
                         percuts.digits=0L,
                         isotonize=TRUE,
                         convert.using.loss.hoss=TRUE,
                         goodness.of.fit=TRUE,
                         goodness.of.fit.minimum.n=NULL,
                         goodness.of.fit.output.format="GROB",
                         return.prior.scale.score=TRUE,
                         return.prior.scale.score.standardized=TRUE,
                         return.norm.group.identifier=TRUE,
                         return.norm.group.scale.scores=NULL,
                         return.norm.group.dates=NULL,
                         return.norm.group.preference=NULL,
                         return.panel.data=identical(parent.frame(), .GlobalEnv),
                         print.time.taken=TRUE,
                         parallel.config=NULL,
                         calculate.simex=NULL,
                         sgp.percentiles.set.seed=314159,
                         sgp.percentiles.equated=NULL,
                         SGPt=NULL,
                         SGPt.max.time=NULL,
                         verbose.output=FALSE)

Arguments

Details

Typical use of the function is to submit a data frame to the function containing records of all students across all grades, allowing the function to subset out specific grade progressions using grade.progression. Additional uses include using pre-calculated results to recalculate SGPs for baseline referencing. studentGrowthPercentiles examples provide code for use in analyzing assessment data across multiple grades.

Value

Function returns an object of class list containing objects: Coefficient_Matrices, Goodness_of_Fit, Knots_Boundaries, Panel_Data, SGPercentiles, Simulated_SGPs.

Author(s)

Damian W. Betebenner [email protected] and Adam Van Iwaarden [email protected]

References

Betebenner, D. W. (2008). Toward a normative understanding of student growth. In K. E. Ryan & L. A. Shepard (Eds.), The Future of Test Based Accountability (pp. 155-170). New York: Routledge.

Betebenner, D. W. (2009). Norm- and criterion-referenced student growth. Educational Measurement: Issues and Practice, 28(4):42-51.

Betebenner, D. W. (2012). Growth, standards, and accountability. In G. J. Cizek, Setting Performance Standards: Foundations, Methods & Innovations. 2nd Edition (pp. 439-450). New York: Routledge.

Castellano, K. E. & McCaffrey, D. F. (2017). The Accuracy of Aggregate Student Growth Percentiles as Indicators of Educator Performance. Educational Measurement: Issues and Practice, 36(1):14-27.

Chernozhukov, V., Fernandez-Val, I. and Galichon, A. (2010), Quantile and Probability Curves Without Crossing. Econometrica, 78: 1093-1125.

Koenker, R. (2005). Quantile regression. Cambridge: Cambridge University Press.

Shang, Y., VanIwaarden, A., & Betebenner, D. W. (2015). Covariate measurement error correction for Student Growth Percentiles using the SIMEX method. Educational Measurement: Issues and Practice, 34(1):4-14.

See Also

studentGrowthProjections, sgpData, sgpData_LONG, SGPstateData

Examples

## Not run: 
## Calculate 4th grade student growth percentiles using included sgpData

require(SGPdata)
sgp_g4 <- studentGrowthPercentiles(
		panel.data=sgpData,
		sgp.labels=list(my.year=2015, my.subject="Reading"),
		percentile.cuts=c(1,35,65,99),
		subset.grade=4,
		num.prior=1)

## NOTE: "grade.progression" can be used in place of "subset.grade" and "num.prior"

sgp_g4_v2 <- studentGrowthPercentiles(
		panel.data=sgpData,
		sgp.labels=list(my.year=2015, my.subject="Reading"),
		percentile.cuts=c(1,35,65,99),
		grade.progression=c(3,4))

identical(sgp_g4$SGPercentiles, sgp_g4_v2$SGPercentiles)

## Established state Knots and Boundaries are available in the supplied SGPstateData
## file and used by supplying the appropriate two letter state acronym.

sgp_g4_DEMO <- studentGrowthPercentiles(
		panel.data=sgpData,
		sgp.labels=list(my.year=2015, my.subject="Reading"),
		use.my.knots.boundaries="DEMO",
		grade.progression=c(3,4))


## Sample code for running non-sequential grade progression analysis.

sgp_g8_DEMO <- studentGrowthPercentiles(
		panel.data=sgpData,
		sgp.labels=list(my.year=2015, my.subject="Reading"),
		use.my.knots.boundaries="DEMO",
		grade.progression=c(5,6,8))


## NOTE: Unless specified with 'goodness.of.fit.output.format'
## Goodness of Fit results are stored as graphical objects in the
## Goodness_of_Fit slot. To view or save (using any R output device) try:
## Load 'grid' package to access grid.draw function

require(grid)
grid.draw(sgp_g4$Goodness_of_Fit$READING.2015[[1]][["PLOT"]])

require(grid)
pdf(file="Grade_4_Reading_2015_GOF.pdf", width=8.5, height=8)
grid.draw(sgp_g4$Goodness_of_Fit$READING.2015[[1]][["PLOT"]])
dev.off()

# Other grades

sgp_g5 <- studentGrowthPercentiles(
		panel.data=sgpData,
		sgp.labels=list(my.year=2015, my.subject="Reading"),
		percentile.cuts=c(1,35,65,99),
		grade.progression=3:5)

sgp_g6 <- studentGrowthPercentiles(
		panel.data=sgpData,
		sgp.labels=list(my.year=2015, my.subject="Reading"),
		percentile.cuts=c(1,35,65,99),
		grade.progression=3:6)

sgp_g7 <- studentGrowthPercentiles(
		panel.data=sgpData,
		sgp.labels=list(my.year=2015, my.subject="Reading"),
		percentile.cuts=c(1,35,65,99),
		grade.progression=3:7)

sgp_g8 <- studentGrowthPercentiles(
		panel.data=sgpData,
		sgp.labels=list(my.year=2015, my.subject="Reading"),
		percentile.cuts=c(1,35,65,99),
		grade.progression=4:8)

## All output of studentGrowthPercentiles (e.g., coefficient matrices) is contained
## in the object.  See, for example, names(sgp_g8), for all included objects.
## Results are stored in the slot SGPercentiles.

# Combine all results

sgp_all <- rbind(
		sgp_g4$SGPercentiles$READING.2015,
		sgp_g5$SGPercentiles$READING.2015,
		sgp_g6$SGPercentiles$READING.2015,
		sgp_g7$SGPercentiles$READING.2015,
		sgp_g8$SGPercentiles$READING.2015)

# Save SGP results to .csv file

write.csv(sgp_all, file="sgp_all.csv", row.names=FALSE, quote=FALSE, na="")


## NOTE: studentGrowthPercentiles ADDs results to the current SGP object.
## This allows one to "recycle" the object for multiple grades and subjects as desired.

# Loop to calculate all SGPs for all grades without percentile cuts
# but with growth levels and goodness of fit plots exported automatically as PDFs, PNGs, SVGs,
# and DECILE_TABLES (10x10 table at bottom left of goodness of fit plots)

my.grade.sequences <- list(3:4, 3:5, 3:6, 3:7, 4:8)
my.sgpData <- list(Panel_Data=sgpData)   ### Put sgpData into Panel_Data slot

for (i in seq_along(my.grade.sequences)) {
	my.sgpData <- studentGrowthPercentiles(panel.data=my.sgpData,
		sgp.labels=list(my.year=2015, my.subject="Reading"),
		growth.levels="DEMO",
		goodness.of.fit="DEMO",
        goodness.of.fit.output.format=c("PDF", "PNG", "SVG", "DECILE_TABLES"),
		grade.progression=my.grade.sequences[[i]])
}

#  Save Student Growth Percentiles results to a .csv file:

write.csv(my.sgpData$SGPercentiles$READING.2015,
file="2015_Reading_SGPercentiles.csv", row.names=FALSE, quote=FALSE, na="")

## Loop to calculate all SGPs for all grades using 2010 to 2013 data

my.grade.sequences <- list(3:4, 3:5, 3:6, 3:7, 4:8)

for (i in seq_along(my.grade.sequences)) {
	my.sgpData_2009 <- studentGrowthPercentiles(panel.data=my.sgpData,
		panel.data.vnames=c("ID", "GRADE_2010",
			"GRADE_2011", "GRADE_2012", "GRADE_2013",
			"SS_2010", "SS_2011", "SS_2012", "SS_2013"),
		sgp.labels=list(my.year=2013, my.subject="Reading"),
		grade.progression=my.grade.sequences[[i]])
}


## Loop to calculate all SGPs for all grades WITH 80

my.grade.sequences <- list(3:4, 3:5, 3:6, 3:7, 4:8)

for (i in seq_along(my.grade.sequences)) {
	my.sgpData <- studentGrowthPercentiles(panel.data=my.sgpData,
	sgp.labels=list(my.year=2015, my.subject="Reading"),
	calculate.confidence.intervals=list(state="DEMO",
	confidence.quantiles=c(0.1, 0.9), simulation.iterations=100,
		distribution="Normal", round=1),
	grade.progression=my.grade.sequences[[i]])
}

### Example showing how to use pre-calculated coefficient
### matrices to calculate student growth percentiles

my.grade.sequences <- list(3:4, 3:5, 3:6, 3:7, 4:8)
my.sgpData <- list(Panel_Data=sgpData)   ### Put sgpData into Panel_Data slot

for (i in seq_along(my.grade.sequences)) {
	my.sgpData <- studentGrowthPercentiles(panel.data=my.sgpData,
		sgp.labels=list(my.year=2015, my.subject="Reading"),
		growth.levels="DEMO",
		grade.progression=my.grade.sequences[[i]])
}

percentiles.1st.run <- my.sgpData$SGPercentiles$READING.2015

### my.sgpData has as full set of coefficient matrices for Reading, 2015. To view these

names(my.sgpData$Coefficient_Matrices$READING.2015)

## Let's NULL out the SGPercentiles slot and recreate the percentiles
## using the embedded coefficient matrices

my.sgpData$SGPercentiles$READING.2015 <- NULL

for (i in seq_along(my.grade.sequences)) {
	my.sgpData <- studentGrowthPercentiles(panel.data=my.sgpData,
		sgp.labels=list(my.year=2015, my.subject="Reading"),
		use.my.knots.boundaries=list(my.year=2015, my.subject="Reading"),
		use.my.coefficient.matrices=list(my.year=2015, my.subject="Reading"),
		growth.levels="DEMO",
		grade.progression=my.grade.sequences[[i]])
}

percentiles.2nd.run <- my.sgpData$SGPercentiles$READING.2015

identical(percentiles.1st.run, percentiles.2nd.run)


## End(Not run)

Description

Function used to produce individual student growth and achievement chart (an achievement time lines indicating student growth) based upon output from student growth percentile and student growth projection analyses. Function is integrated with SGPstateData to accommodate state specific scales and nomenclature including performance level names. See Betebenner (2012) for discussion

Usage

studentGrowthPlot(Scale_Scores,
	Plotting_Scale_Scores, 
	Achievement_Levels, 
	SGP, 
	SGP_Levels, 
	Grades,
	Content_Areas,
	Cuts,
	Plotting_Cuts,
	SGP_Targets,
	SGP_Scale_Score_Targets,
	Plotting_SGP_Scale_Score_Targets,
	Cutscores,
	Years,
	Report_Parameters)

Arguments

Details

Function currently used as part of SGP package to produce student growth charts for states. Function is usually called from the higher level function visualizeSGP which allows for the creation of a student growth plot catalog for each school with student reports organized by grade and student name.

Value

Returns a student growth plot graphical object that is usually exported in either PDF or PNG format.

Author(s)

Damian W. Betebenner [email protected]

References

Betebenner, D. W. (2012). Growth, standards, and accountability. In G. J. Cizek, Setting Performance Standards: Foundations, Methods & Innovations. 2nd Edition (pp. 439-450). New York: Routledge.

Description

Function includes five "styles" associated with studentGrowthPlot to create PDF student growth plots depicting the growth and achievement for an individual student over time. The five styles display one to five content area student growth plots on a single page. The one, two, and three content area plots are rendered on 8.5 by 11 PDFs and the four and five content area plots are rendered on 11 by 17 PDFs. These charts are currently being used in multiple states to report student growth results. This function is called by visualizeSGP to generate individual student reports. This function may expand in the future to incorporate other possible individual student reports.

Usage

studentGrowthPlot_Styles(
           sgPlot.data,
           sgPlot.sgp_object,
           sgPlot.cutscores,
           state,
           last.year,
           content_areas,
           districts,
           schools,
           reports.by.student,
           reports.by.instructor,
           reports.by.school,
           sgPlot.years,
           sgPlot.demo.report,
           sgPlot.folder,
           sgPlot.folder.names,
           sgPlot.anonymize,
           sgPlot.front.page,
           sgPlot.header.footer.color,
           sgPlot.fan,
	   sgPlot.sgp.targets,
           sgPlot.cleanup,
           sgPlot.baseline,
	   sgPlot.sgp.targets.timeframe,
           sgPlot.zip,
           sgPlot.output.format,
           sgPlot.linkages)

Arguments

Details

studentGrowthPlot_Styles is a utility function containing five templates for displaying studentGrowthPlots. The templates display two or three content areas depending upon the availability of test data for the state. This function will expand in the future to allow for other types of individual growth and achievement reports.

Value

Function produces numerous (potentially hundreds of thousands of) PDF/PNG student growth plots.

Author(s)

Damian W. Betebenner [email protected] and Adam Van Iwaarden [email protected]

References

Betebenner, D. W. (2012). Growth, standards, and accountability. In G. J. Cizek, Setting Performance Standards: Foundations, Methods & Innovations. 2nd Edition (pp. 439-450). New York: Routledge.

Description

Function to calculate percentile growth projections/trajectories using large scale assessment data and results derived from student growth percentile calculation. Function can produce percentile growth trajectories, as well as growth percentiles, sufficient for each student to reach a set of predefined scale score cut.

Usage

studentGrowthProjections(panel.data,
                         sgp.labels,
                         grade.progression,
                         content_area.progression=NULL,
                         year_lags.progression=NULL,
                         grade.projection.sequence=NULL,
                         content_area.projection.sequence=NULL,
                         year_lags.projection.sequence=NULL,
                         max.forward.progression.years=NULL,
                         max.forward.progression.grade=NULL,
                         max.order.for.progression,
                         use.my.knots.boundaries,
                         use.my.coefficient.matrices,
                         panel.data.vnames,
                         achievement.level.prior.vname=NULL,
                         performance.level.cutscores,
                         calculate.sgps=TRUE,
                         convert.0and100=TRUE,
                         trajectories.chunk.size=50000L,
                         sgp.projections.equated=NULL,
                         projection.unit="YEAR",
                         projection.unit.label=NULL,
                         percentile.trajectory.values=NULL,
                         percentile.trajectory.values.max.forward.progression.years=NULL,
                         return.percentile.trajectory.values=NULL,
                         return.projection.group.identifier=NULL,
                         return.projection.group.scale.scores=NULL,
                         return.projection.group.dates=NULL,
                         isotonize=TRUE,
                         lag.increment=0L,
                         lag.increment.label=NULL,
                         sgp.exact.grade.progression=FALSE,
                         projcuts.digits=NULL,
                         sgp.projections.use.only.complete.matrices=NULL,
                         SGPt=NULL,
                         print.time.taken=TRUE)

Arguments

  performance.level.cutscores <- list(
         Reading=list(GRADE_3=c(cut1, cut2, cut3),
                      GRADE_4=c(cut1, cut2, cut3),
                       . . .
                      GRADE_8=c(cut1, cut2, cut3)),
            Math=list(GRADE_3=c(cut1, cut2, cut3),
                       . . .
                      GRADE_7=c(cut1, cut2, cut3),
                      GRADE_8=c(cut1, cut2, cut3)))

Value

Function returns the input panel.data list object with the additional percentile growth trajectories/percentiles stored in panel.data$SGProjections$my.year.my.subject consisting of student IDs and the associated percentile growth projections/trajectories and cuts. The data frame contains projections/trajectories for each performance level cut-point supplied and each percentile cut the user specifies.

Note

Use of this function assumes prior calculation of student growth percentiles, making the coefficient matrices available within the panel.data$Coefficient_Matrices list object. Additionally, if cutscores are desired they must be supplied explicitly by the user (as detailed above in performance.level.cutscores) or included in the SGPstateData data set. If your state's cutscores are not included or are incorrect, please contact [email protected] to have cutscores added or corrected!

Author(s)

Damian W. Betebenner [email protected] and Adam Van Iwaarden [email protected]

References

Betebenner, D. W. (2008). Toward a normative understanding of student growth. In K. E. Ryan & L. A. Shepard (Eds.), The Future of Test Based Accountability (pp. 155-170). New York: Routledge.

Betebenner, D. W. (2009). Norm- and criterion-referenced student growth. Educational Measurement: Issues and Practice, 28(4):42-51.

Betebenner, D. W. (2012). Growth, standards, and accountability. In G. J. Cizek, Setting Performance Standards: Foundations, Methods & Innovations. 2nd Edition (pp. 439-450). New York: Routledge.

Chernozhukov, V., Fernandez-Val, I. and Galichon, A. (2010), Quantile and Probability Curves Without Crossing. Econometrica, 78: 1093-1125.

See Also

studentGrowthPercentiles, sgpData

Examples

## Not run: 
## First calculate SGPs for 2014
my.grade.sequences <- list(3:4, 3:5, 3:6, 3:7, 4:8)
my.sgpData <- list(Panel_Data = sgpData)

for (i in seq_along(my.grade.sequences)) {
	my.sgpData <- studentGrowthPercentiles(panel.data=my.sgpData,
		sgp.labels=list(my.year=2014, my.subject="Reading"),
		use.my.knots.boundaries="DEMO",
		grade.progression=my.grade.sequences[[i]])
}

## Calculate Growth Projections

my.grade.progressions <- list(3, 3:4, 3:5, 3:6, 4:7)

for (i in seq_along(my.grade.progressions)) {
	my.sgpData <- studentGrowthProjections(panel.data=my.sgpData,
		sgp.labels=list(my.year=2014, my.subject="Reading"),
		projcuts.digits=0,
		projection.unit="GRADE",
		performance.level.cutscores="DEMO",
		percentile.trajectory.values=c(25, 50, 75),
		grade.progression=my.grade.progressions[[i]])
}

##  Save the Student Growth Projections Results to a .csv file:

write.csv(my.sgpData$SGProjections$READING.2014,
file= "2014_Reading_SGProjections.csv", row.names=FALSE, quote=FALSE)

## End(Not run)

Description

Utility function used to produce summary tables using long formatted data that contain student growth percentiles. An exemplar is provided from the successive execution of prepareSGP, analyzeSGP and combineSGP.

Usage

summarizeSGP(sgp_object,
           state,
           years,
           content_areas,
           sgp.summaries=NULL,
           summary.groups=NULL,
           confidence.interval.groups=NULL,
           produce.all.summary.tables=FALSE,
           summarizeSGP.baseline=NULL,
           projection.years.for.target=NULL,
           save.old.summaries=FALSE,
           highest.level.summary.grouping="STATE",
           parallel.config=NULL)

Arguments

Details

Function makes use of the foreach package to parallel process summary tables of student data. The proper choice of parallel backend is dependent upon the user's operating system, software and system memory capacity. Please see the foreach documentation for details. By default, the function will process the summary tables sequentially.

Value

Function returns lists containing the summary tables as data.table objects in the @Summary slot of the SGP data object. Each institution has a slot in the @Summary list.

Author(s)

Damian W. Betebenner [email protected] and Adam Van Iwaarden [email protected]

See Also

prepareSGP, analyzeSGP, combineSGP

Examples

## Not run: 
## summarizeSGP is Step 4 of 5 of abcSGP
Demonstration_SGP <- sgpData_LONG
Demonstration_SGP <- prepareSGP(Demonstration_SGP)
Demonstration_SGP <- analyzeSGP(Demonstration_SGP)
Demonstration_SGP <- combineSGP(Demonstration_SGP)
Demonstration_SGP <- summarizeSGP(Demonstration_SGP)

###  Example uses of the parallel.config argument

##  Windows users  must use the parallel package and R version >= 2.13:
#  Note the number of workers is 8, and PSOCK type cluster is used.
#  This example is would be good for a single workstation with 8 cores.
	. . .
	parallel.config=list(
		BACKEND="PARALLEL", TYPE="PSOCK",
		WORKERS=list(SUMMARY=2))
	. . .

#  doParallel package - only available with R 2.13 or newer
	. . .
	parallel.config=list(
		BACKEND="FOREACH", TYPE="doParallel",
		WORKERS=list(SUMMARY=6))
	. . .

##  parallel package - only available with R 2.13 or newer
#  Note the number of workers is 50, and MPI is used,
#  suggesting this example is for a HPC cluster usage.
	. . .
	parallel.config=list(
		BACKEND="PARALLEL", TYPE="MPI"),
		WORKERS=list(SUMMARY=50))
	. . .

#  NOTE:  This list of parallel.config specifications is NOT exhaustive.
#  See examples in analyzeSGP documentation for some others.

## End(Not run)

Description

testSGP runs large scale tests of the SGP package to test for consistent performance across releases.

Usage

testSGP(TEST_NUMBER,
	save.results=TRUE,
	test.option=list(),
	memory.profile=FALSE,
	stop.fail=TRUE)

Arguments

Value

Returns output associated with functions being run.

Author(s)

Damian W. Betebenner [email protected] and Adam Van Iwaarden [email protected]

See Also

abcSGP

Examples

## Not run: 
## testSGP(0): Test of studentGrowthPercentiles, studentGrowthProjections, and sgpData
testSGP(0)

## testSGP(1) & testSGP('1b') runs abcSGP for all years in sgpData_LONG with/without sqliteSGP
testSGP(1)
testSGP('1b')

## testSGP(2): Various tests of updateSGP functionality.
## testSGP('2a'): Test of updateSGP performing SGP analyses in two steps:
##	Create what_sgp_object: 2010-2011 to 2013-2014 then add with_sgp_data_LONG 2014-2015 using
##	overwrite.existing.data=FALSE and sgp.use.my.coefficient.matrices=FALSE.
## testSGP('2b'): Test of updateSGP performing SGP analyses in two steps:
## 	Create what_sgp_object: 2010-2011 to 2013-2014 then add with_sgp_data_LONG 2014-2015 using
##	overwrite.existing.data=TRUE and sgp.use.my.coefficient.matrices=FALSE.
## testSGP('2c'): Test of updateSGP performing SGP analyses in two steps:
##	Create what_sgp_object: 2010-2011 to 2013-2014 then add with_sgp_data_LONG 2014-2015 using
##	overwrite.existing.data=TRUE and sgp.use.my.coefficient.matrices=TRUE.
## testSGP('2d'): Test of updateSGP performing SGP analyses in two steps:
##	Create what_sgp_object: 2010-2011 to 2013-2014 then add with_sgp_data_LONG 2014-2015 using
##	overwrite.existing.data=FALSE and sgp.use.my.coefficient.matrices=TRUE.
testSGP('2a')
testSGP('2b')
testSGP('2c')
testSGP('2d')

## testSGP(3) runs abcSGP on grade progressions including End of Course Tests in Mathematics
## (Algebra I and Algebra II) and Reading (Grade 9 Literature and American Literature)
testSGP(3)

## testSGP(4) runs prepareSGP and analyzeSGP with simex adjustment for measurement error
testSGP(4)

## testSGP(5) runs abcSGP assuming at test transition in the most recent year. NOTE YET COMPLETED
testSGP(5)

## testSGP(6) runs a basic baseline SGP analysis including the construction of baseline matrices.
testSGP(6)

## End(Not run)

Description

updateSGP takes an object of class SGP and adds in additional data (usually an additional year's data) and runs analyses on that additional year's data including the results in the supplied SGP object.

Usage

updateSGP(
	what_sgp_object=NULL,
	with_sgp_data_LONG=NULL,
	with_sgp_data_INSTRUCTOR_NUMBER=NULL,
	state=NULL,
	steps=c("prepareSGP",
		"analyzeSGP",
		"combineSGP",
		"summarizeSGP",
		"visualizeSGP",
		"outputSGP"),
	years=NULL,
	content_areas=NULL,
	grades=NULL,
	sgp.percentiles=TRUE,
	sgp.projections=TRUE,
	sgp.projections.lagged=TRUE,
	sgp.percentiles.baseline=TRUE,
	sgp.projections.baseline=TRUE,
	sgp.projections.lagged.baseline=TRUE,
	sgp.test.cohort.size=NULL,
	return.sgp.test.results=FALSE,
	simulate.sgps=TRUE,
	save.old.summaries=NULL,
	save.intermediate.results=TRUE,
	calculate.simex=NULL,
	calculate.simex.baseline=NULL,
	sgp.use.my.coefficient.matrices=NULL,
	sgp.target.scale.scores=FALSE,
	sgp.target.scale.scores.only=FALSE,
	overwrite.existing.data=TRUE,
	update.old.data.with.new=TRUE,
	output.updated.data=TRUE,
	sgPlot.demo.report=TRUE,
	plot.types=c("bubblePlot", "studentGrowthPlot", "growthAchievementPlot"),
	outputSGP.output.type=c("LONG_Data",
				"LONG_FINAL_YEAR_Data",
				"WIDE_Data",
				"INSTRUCTOR_Data"),
	outputSGP.directory="Data",
	sgp.config=NULL,
	goodness.of.fit.print=TRUE,
	parallel.config=NULL,
	sgp.sqlite=FALSE,
	SGPt=NULL,
	sgp.percentiles.equated=NULL,
	sgp.percentiles.equating.method=NULL,
	sgp.percentiles.calculate.sgps=TRUE,
	fix.duplicates=NULL,
	get.cohort.data.info=FALSE,
	...)

Arguments

Value

Returns and object of class SGP including additional analyses.

Author(s)

Damian W. Betebenner [email protected]

See Also

prepareSGP and abcSGP

Examples

## Not run: 
### Run analyses on all but final year's of data

Demonstration_Data_LONG <- subset(sgpData_LONG, YEAR 
Demonstration_Data_LONG_2013_2014 <- subset(sgpData_LONG, YEAR 

Demonstration_SGP <- abcSGP(
        sgp_object=Demonstration_Data_LONG,
        sgPlot.demo.report=TRUE)


### Run updateSGP on Demonstration_SGP and the 2013_2014 data

Demonstration_SGP <- updateSGP(
        what_sgp_object=Demonstration_SGP,
        with_sgp_data_LONG=Demonstration_Data_LONG_2013_2014)

## End(Not run)

Description

Utility function to produce a variety of graphical displays associated with student growth percentile/percentile growth trajectory results. Function currently includes facility to produce individual student growth and achievement plots, interactive bubble plots depicting summary growth and achievement data, and growth and achievement charts showing system level growth and achievement data as shown on the cover of Educational Measurement: Issues and Practice as part of Betebenner (2009) and Betebenner (2012).

Usage

visualizeSGP(
        sgp_object,
        plot.types=c("bubblePlot", "studentGrowthPlot", "growthAchievementPlot"),
        state,
        bPlot.years=NULL,
        bPlot.content_areas=NULL,
        bPlot.districts=NULL,
        bPlot.schools=NULL,
        bPlot.instructors=NULL,
        bPlot.styles=c(1),
        bPlot.levels=NULL,
        bPlot.level.cuts=NULL,
        bPlot.full.academic.year=TRUE,
        bPlot.minimum.n=10,
        bPlot.anonymize=FALSE,
        bPlot.prior.achievement=TRUE,
        bPlot.draft=FALSE,
        bPlot.demo=FALSE,
        bPlot.output="PDF",
        bPlot.format="print",
        bPlot.folder="Visualizations/bubblePlots",
        sgPlot.save.sgPlot.data=FALSE,
        sgPlot.years=NULL,
        sgPlot.content_areas=NULL,
        sgPlot.districts=NULL,
        sgPlot.schools=NULL,
        sgPlot.reports.by.school=TRUE,
        sgPlot.instructors=NULL,
        sgPlot.reports.by.instructor=FALSE,
        sgPlot.students=NULL,
        sgPlot.reports.by.student=FALSE,
        sgPlot.reports.group.vars=
            list(DISTRICT_NUMBER="DISTRICT_NUMBER", SCHOOL_NUMBER="SCHOOL_NUMBER"),
        sgPlot.header.footer.color="#4CB9CC",
        sgPlot.front.page=NULL,
        sgPlot.folder="Visualizations/studentGrowthPlots",
        sgPlot.folder.names="number",
        sgPlot.fan=TRUE,
        sgPlot.custom.trajectory=FALSE,
        sgPlot.sgp.targets=FALSE,
        sgPlot.sgp.targets.timeframe=3,
        sgPlot.anonymize=FALSE,
        sgPlot.cleanup=TRUE,
        sgPlot.demo.report=FALSE,
        sgPlot.produce.plots=TRUE,
        sgPlot.baseline=NULL,
        sgPlot.zip=TRUE,
        sgPlot.output.format="PDF",
        sgPlot.year.span=5,
        sgPlot.plot.test.transition=TRUE,
        gaPlot.years=NULL,
        gaPlot.content_areas=NULL,
        gaPlot.students=NULL,
        gaPlot.format="print",
        gaPlot.baseline=NULL,
        gaPlot.max.order.for.progression=NULL,
        gaPlot.start.points="Achievement Level Cuts",
        gaPlot.back.extrapolated.cuts=NULL,
        gaPlot.SGPt=NULL,
        gaPlot.folder="Visualizations/growthAchievementPlots",
        parallel.config=NULL)