/*!\file ControlInput.c
 * \brief: implementation of the ControlInput object
 */

#ifdef HAVE_CONFIG_H
	#include <config.h>
#else
#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!"
#endif

#include <stdio.h>
#include <string.h>
#include "../objects.h"
#include "../../EnumDefinitions/EnumDefinitions.h"
#include "../../shared/shared.h"
#include "../../Container/Container.h"
#include "../../include/include.h"

/*ControlInput constructors and destructor*/
/*FUNCTION ControlInput::ControlInput(){{{1*/
ControlInput::ControlInput(){
	control_id  = 0;
	values      = NULL;
	savedvalues = NULL;
	minvalues   = NULL;
	maxvalues   = NULL;
	gradient    = NULL;
}
/*}}}*/
/*FUNCTION ControlInput::ControlInput(int enum_type,int enum_input,double* pvalues,double* pmin,double* pmax,int id){{{1*/
ControlInput::ControlInput(int in_enum_type,int enum_input,double* pvalues,double* pmin,double* pmax,int id){

	control_id=id;
	enum_type=in_enum_type;

	switch(enum_input){
		case TriaP1InputEnum:
			values     =new TriaP1Input(enum_type,pvalues);
			savedvalues=new TriaP1Input(enum_type,pvalues);
			minvalues  =new TriaP1Input(enum_type,pmin);
			maxvalues  =new TriaP1Input(enum_type,pmax);
			break;
		case PentaP1InputEnum:
			values     =new PentaP1Input(enum_type,pvalues);
			savedvalues=new PentaP1Input(enum_type,pvalues);
			minvalues  =new PentaP1Input(enum_type,pmin);
			maxvalues  =new PentaP1Input(enum_type,pmax);
			break;
		default:
			_error_("Input of Enum %s not supported yet by ControlInput",EnumToStringx(enum_input));
	}
	gradient   =NULL;
}
/*}}}*/
/*FUNCTION ControlInput::~ControlInput(){{{1*/
ControlInput::~ControlInput(){
	delete values;
	delete savedvalues;
	delete minvalues;
	delete maxvalues;
	delete gradient;
}
/*}}}*/

/*Object virtual functions definitions:*/
		/*FUNCTION ControlInput::Echo {{{1*/
void ControlInput::Echo(void){
	this->DeepEcho();
}
/*}}}*/
/*FUNCTION ControlInput::DeepEcho{{{1*/
void ControlInput::DeepEcho(void){

	printf("ControlInput:\n");
	printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
	printf("---values: \n");     if (values)      values->Echo();
	printf("---savedvalues: \n");if (savedvalues) savedvalues->Echo();
	printf("---minvalues: \n");  if (minvalues)   minvalues->Echo();
	printf("---maxvalues: \n");  if (maxvalues)   maxvalues->Echo();
	printf("---gradient: \n");   if (gradient)    gradient->Echo();
}
/*}}}*/
/*FUNCTION ControlInput::Id{{{1*/
int    ControlInput::Id(void){ return -1; }
/*}}}*/
/*FUNCTION ControlInput::MyRank{{{1*/
int    ControlInput::MyRank(void){ 
	extern int my_rank;
	return my_rank; 
}
/*}}}*/
/*FUNCTION ControlInput::ObjectEnum{{{1*/
int ControlInput::ObjectEnum(void){

	return ControlInputEnum;

}
/*}}}*/
/*FUNCTION ControlInput::copy{{{1*/
Object* ControlInput::copy() {
	
	ControlInput* output=NULL;

	output = new ControlInput();
	output->enum_type=this->enum_type;
	output->control_id=this->control_id;

	if(values)      output->values=(Input*)this->values->copy();
	if(savedvalues) output->savedvalues=(Input*)this->savedvalues->copy();
	if(minvalues)   output->minvalues=(Input*)this->minvalues->copy();
	if(maxvalues)   output->maxvalues=(Input*)this->maxvalues->copy();
	if(gradient)    output->gradient=(Input*)this->gradient->copy();

	return output;
}
/*}}}*/
	
/*ControlInput management*/
/*FUNCTION ControlInput::InstanceEnum{{{1*/
int ControlInput::InstanceEnum(void){

	return this->enum_type;

}
/*}}}*/

/*Object functions*/
/*FUNCTION ControlInput::Constrain(){{{1*/
void ControlInput::Constrain(void){

	Input* newvalues=NULL;

	newvalues=this->values->PointwiseMin(maxvalues);
	delete values; this->values=newvalues;
	newvalues=this->values->PointwiseMax(minvalues);
	delete values; this->values=newvalues;
}/*}}}*/
/*FUNCTION ControlInput::Constrain(double min, double max){{{1*/
void ControlInput::Constrain(double min, double max){
	   values->Constrain(min,max);
}/*}}}*/
/*FUNCTION ControlInput::Extrude{{{1*/
void ControlInput::Extrude(void){
	values->Extrude();
	savedvalues->Extrude();
	//gradient->Extrude();
}/*}}}*/
/*FUNCTION ControlInput::GetGradient{{{1*/
void ControlInput::GetGradient(Vector* gradient_vec,int* doflist){
	if(gradient) gradient->GetVectorFromInputs(gradient_vec,doflist);
}/*}}}*/
/*FUNCTION ControlInput::ScaleGradient{{{1*/
void ControlInput::ScaleGradient(double scaling_factor){
	if(!gradient) _error_("Gradient of ControlInput %s not found",EnumToStringx(enum_type));
	gradient->Scale(scaling_factor);
}/*}}}*/
/*FUNCTION ControlInput::SetGradient{{{1*/
void ControlInput::SetGradient(Input* gradient_in){

	/*Get enum for current gradient*/
	switch(this->control_id){
		case 1:
			gradient_in->ChangeEnum(Gradient1Enum);
			break;
		case 2:
			gradient_in->ChangeEnum(Gradient2Enum);
			break;
		case 3:
			gradient_in->ChangeEnum(Gradient3Enum);
			break;
		default:
			_error_("more than 3 controls not implemented yet (Gradient %i was requested). EnumDefinitions.h needs to be updated.",this->control_id);
	}

	/*Delete old gradient and assign new gradient*/
	if(gradient) delete gradient;
	gradient=gradient_in;

}/*}}}*/
/*FUNCTION ControlInput::SetInput{{{1*/
void ControlInput::SetInput(Input* in_input){

	delete values; this->values=in_input;
	this->SaveValue(); //because this is what SpawnResult saves FIXME

}/*}}}*/
/*FUNCTION ControlInput::SpawnResult{{{1*/
ElementResult* ControlInput::SpawnResult(int step, double time){
	return savedvalues->SpawnResult(step,time);
}/*}}}*/
/*FUNCTION ControlInput::SpawnTriaInput{{{1*/
Input* ControlInput::SpawnTriaInput(int* indices){
	return values->SpawnTriaInput(indices);
}/*}}}*/
/*FUNCTION ControlInput::SpawnGradient{{{1*/
ElementResult* ControlInput::SpawnGradient(int step, double time){
	_assert_(gradient);
	return gradient->SpawnResult(step,time);
}/*}}}*/
/*FUNCTION ControlInput::GetVectorFromInputs(Vector* vector,int* doflist){{{1*/
void ControlInput::GetVectorFromInputs(Vector* vector,int* doflist){
	values->GetVectorFromInputs(vector,doflist);
}/*}}}*/
/*FUNCTION ControlInput::GetVectorFromInputs(Vector* vector,int* doflist,const char* data){{{1*/
void ControlInput::GetVectorFromInputs(Vector* vector,int* doflist,const char* data){
	 if(strcmp(data,"value")==0){
		 _assert_(values);
		 values->GetVectorFromInputs(vector,doflist);
	 }
	 else if (strcmp(data,"lowerbound")==0){
		 _assert_(minvalues);
		 minvalues->GetVectorFromInputs(vector,doflist);
	 }
	 else if (strcmp(data,"upperbound")==0){
		 _assert_(maxvalues);
		 maxvalues->GetVectorFromInputs(vector,doflist);
	 }
	 else if (strcmp(data,"gradient")==0){
		 _assert_(gradient);
		 gradient->GetVectorFromInputs(vector,doflist);
	 }
	 else{
		 _error_("Data %s not supported yet",data);
	 }
}/*}}}*/
/*FUNCTION ControlInput::GetInputAverage(double* pvalue){{{1*/
void ControlInput::GetInputAverage(double* pvalue){
	values->GetInputAverage(pvalue);
}/*}}}*/
/*FUNCTION ControlInput::GetInputValue(bool* pvalue){{{1*/
void ControlInput::GetInputValue(bool* pvalue){
	values->GetInputValue(pvalue);
}/*}}}*/
/*FUNCTION ControlInput::GetInputValue(int* pvalue){{{1*/
void ControlInput::GetInputValue(int* pvalue){
	values->GetInputValue(pvalue);
}/*}}}*/
/*FUNCTION ControlInput::GetInputValue(double* pvalue){{{1*/
void ControlInput::GetInputValue(double* pvalue){
	values->GetInputValue(pvalue);
}/*}}}*/
/*FUNCTION ControlInput::GetInputValue(double* pvalue){{{1*/
void ControlInput::GetInputValue(double* pvalue,GaussTria* gauss){
	values->GetInputValue(pvalue,gauss);
}/*}}}*/
/*FUNCTION ControlInput::GetInputValue(double* pvalue){{{1*/
void ControlInput::GetInputValue(double* pvalue,GaussPenta* gauss){
	values->GetInputValue(pvalue,gauss);
}/*}}}*/
/*FUNCTION ControlInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){{{1*/
void ControlInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){
	values->GetInputDerivativeValue(derivativevalues,xyz_list,gauss);
}/*}}}*/
/*FUNCTION ControlInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){{{1*/
void ControlInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){
	values->GetInputDerivativeValue(derivativevalues,xyz_list,gauss);
}/*}}}*/
/*FUNCTION ControlInput::SaveValue{{{1*/
void ControlInput::SaveValue(void){
	if(!values) _error_("Values of %s not found",EnumToStringx(this->enum_type));

	if(savedvalues) delete this->savedvalues;
	this->savedvalues=(Input*)this->values->copy();
}/*}}}*/
/*FUNCTION ControlInput::UpdateValue{{{1*/
void ControlInput::UpdateValue(double scalar){
	if(!gradient)    _error_("Gradient of %s not found",EnumToStringx(this->enum_type));
	if(!savedvalues) _error_("Values of %s not found",EnumToStringx(this->enum_type));

	if(values) delete this->values;
	this->values=(Input*)this->savedvalues->copy();
	this->values->AXPY(gradient,scalar);
}/*}}}*/
/*FUNCTION ControlInput::VerticallyIntegrate{{{1*/
void ControlInput::VerticallyIntegrate(Input* thickness_input){
	values->VerticallyIntegrate(thickness_input);
}/*}}}*/
/*FUNCTION ControlInput::Configure{{{1*/
void ControlInput::Configure(Parameters* parameters){
	/*do nothing: */
}
/*}}}*/