Index: /issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.cpp (revision 18473) +++ /issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.cpp (revision 18474) @@ -112,5 +112,5 @@ /*XTH LATH parameters*/ iomodel->Constant(&fe_FS,FlowequationFeFSEnum); - if(fe_FS==XTaylorHoodEnum || fe_FS==LATaylorHoodEnum){ + if(fe_FS==XTaylorHoodEnum || fe_FS==LATaylorHoodEnum || fe_FS==LACrouzeixRaviartEnum){ parameters->AddObject(iomodel->CopyConstantObject(AugmentedLagrangianREnum)); parameters->AddObject(iomodel->CopyConstantObject(AugmentedLagrangianRlambdaEnum)); @@ -247,5 +247,5 @@ /*LATH parameters*/ iomodel->Constant(&fe_FS,FlowequationFeFSEnum); - if(fe_FS==LATaylorHoodEnum){ + if(fe_FS==LATaylorHoodEnum || fe_FS==LACrouzeixRaviartEnum){ iomodel->FetchDataToInput(elements,PressureEnum,0.); InputUpdateFromConstantx(elements,0.,SigmaNNEnum); @@ -428,13 +428,14 @@ /*Deduce velocity interpolation from finite element*/ switch(finiteelement){ - case P1P1Enum : finiteelement = P1Enum; break; - case P1P1GLSEnum : finiteelement = P1Enum; break; - case MINIcondensedEnum : finiteelement = P1bubbleEnum; break; - case MINIEnum : finiteelement = P1bubbleEnum; break; - case TaylorHoodEnum : finiteelement = P2Enum; break; - case XTaylorHoodEnum : finiteelement = P2Enum; break; - case LATaylorHoodEnum : finiteelement = P2Enum; break; - case OneLayerP4zEnum : finiteelement = P2xP4Enum; break; - case CrouzeixRaviartEnum : finiteelement = P2bubbleEnum; break; + case P1P1Enum : finiteelement = P1Enum; break; + case P1P1GLSEnum : finiteelement = P1Enum; break; + case MINIcondensedEnum : finiteelement = P1bubbleEnum; break; + case MINIEnum : finiteelement = P1bubbleEnum; break; + case TaylorHoodEnum : finiteelement = P2Enum; break; + case XTaylorHoodEnum : finiteelement = P2Enum; break; + case LATaylorHoodEnum : finiteelement = P2Enum; break; + case LACrouzeixRaviartEnum : finiteelement = P2bubbleEnum; break; + case OneLayerP4zEnum : finiteelement = P2xP4Enum; break; + case CrouzeixRaviartEnum : finiteelement = P2bubbleEnum; break; default: _error_("finite element "<0) @@ -2943,4 +2944,6 @@ else if(fe_FS==LATaylorHoodEnum) Ke1=CreateKMatrixFSViscousLATH(element); + else if(fe_FS==LACrouzeixRaviartEnum) + Ke1=CreateKMatrixFSViscousLACR(element); else Ke1=CreateKMatrixFSViscous(element); @@ -3086,4 +3089,134 @@ return Ke; }/*}}}*/ +ElementMatrix* StressbalanceAnalysis::CreateKMatrixFSViscousLACR(Element* element){/*{{{*/ + + /*Intermediaries*/ + int i,dim,epssize; + IssmDouble r,rl,Jdet,viscosity,DU,DUl; + IssmDouble normal[3]; + IssmDouble *xyz_list = NULL; + IssmDouble *xyz_list_base = NULL; + + /*Get problem dimension*/ + element->FindParam(&dim,DomainDimensionEnum); + element->FindParam(&r,AugmentedLagrangianREnum); + if(dim==2) epssize = 3; + else epssize = 6; + + /*Fetch number of nodes and dof for this finite element*/ + int vnumnodes = element->NumberofNodesVelocity(); + int pnumnodes = element->GetNumberOfNodes(P1DGEnum); + int lnumnodes = element->GetNumberOfNodes(P2Enum); + int numdof = vnumnodes*dim; + int pnumdof = pnumnodes; + int lnumdof = lnumnodes; + + /*Prepare coordinate system list*/ + int* cs_list = xNew(vnumnodes); + if(dim==2) for(i=0;iNewElementMatrix(FSvelocityEnum); + IssmDouble* B = xNew(epssize*numdof); + IssmDouble* Bprime = xNew(epssize*numdof); + IssmDouble* BtBUzawa = xNewZeroInit(numdof*pnumdof); + IssmDouble* BU = xNew(pnumdof); + IssmDouble* BprimeU = xNew(numdof); + IssmDouble* D = xNewZeroInit(epssize*epssize); + + /*Retrieve all inputs and parameters*/ + element->GetVerticesCoordinates(&xyz_list); + Input* vx_input = element->GetInput(VxEnum); _assert_(vx_input); + Input* vy_input = element->GetInput(VyEnum); _assert_(vy_input); + Input* vz_input = NULL; + if(dim==3){vz_input = element->GetInput(VzEnum); _assert_(vz_input);} + + /* Start looping on the number of gaussian points: */ + Gauss* gauss = element->NewGauss(5); + for(int ig=gauss->begin();igend();ig++){ + gauss->GaussPoint(ig); + + element->JacobianDeterminant(&Jdet,xyz_list,gauss); + this->GetBFSvel(B,element,dim,xyz_list,gauss); + this->GetBFSprimevel(Bprime,element,dim,xyz_list,gauss); + + element->ViscosityFS(&viscosity,dim,xyz_list,gauss,vx_input,vy_input,vz_input); + for(i=0;iweight*Jdet; + + TripleMultiply(B,epssize,numdof,1, + D,epssize,epssize,0, + Bprime,epssize,numdof,0, + &Ke->values[0],1); + + this->GetBFSUzawa(BU,element,dim,xyz_list,gauss); + this->GetBFSprimeUzawa(BprimeU,element,dim,xyz_list,gauss); + + DU = gauss->weight*Jdet*sqrt(r); + + TripleMultiply(BU,1,pnumdof,1, + &DU,1,1,0, + BprimeU,1,numdof,0, + BtBUzawa,1); + } + + if(element->IsOnBase() && 0){ + element->FindParam(&rl,AugmentedLagrangianRlambdaEnum); + element->GetVerticesCoordinatesBase(&xyz_list_base); + element->NormalBase(&normal[0],xyz_list_base); + + IssmDouble* Dlambda = xNewZeroInit(dim*dim); + IssmDouble* C = xNewZeroInit(dim*lnumdof); + IssmDouble* Cprime = xNewZeroInit(dim*numdof); + IssmDouble* CtCUzawa = xNewZeroInit(numdof*lnumdof); + + delete gauss; + gauss = element->NewGaussBase(5); + for(int ig=gauss->begin();igend();ig++){ + gauss->GaussPoint(ig); + + element->JacobianDeterminantBase(&Jdet,xyz_list_base,gauss); + this->GetCFS(C,element,dim,xyz_list,gauss); + this->GetCFSprime(Cprime,element,dim,xyz_list,gauss); + for(i=0;iweight*Jdet*sqrt(normal[i]*normal[i])*sqrt(rl); + TripleMultiply(C,dim,lnumdof,1, + Dlambda,dim,dim,0, + Cprime,dim,numdof,0, + CtCUzawa,1); + } + + /*The sigma naugmentation should not be transformed*/ + MatrixMultiply(CtCUzawa,lnumdof,numdof,1, + CtCUzawa,lnumdof,numdof,0, + &Ke->values[0],1); + + /*Delete base part*/ + xDelete(Dlambda); + xDelete(C); + xDelete(Cprime); + xDelete(CtCUzawa); + xDelete(xyz_list_base); + } + + /*Transform Coordinate System*/ + element->TransformStiffnessMatrixCoord(Ke,cs_list); + + /*The pressure augmentation should not be transformed*/ + MatrixMultiply(BtBUzawa,pnumdof,numdof,1, + BtBUzawa,pnumdof,numdof,0, + &Ke->values[0],1); + + /*Clean up and return*/ + delete gauss; + xDelete(xyz_list); + xDelete(D); + xDelete(Bprime); + xDelete(B); + xDelete(BprimeU); + xDelete(BU); + xDelete(BtBUzawa); + xDelete(cs_list); + return Ke; +}/*}}}*/ ElementMatrix* StressbalanceAnalysis::CreateKMatrixFSViscousXTH(Element* element){/*{{{*/ @@ -3446,4 +3579,11 @@ else if(fe_FS==LATaylorHoodEnum){ ElementVector* pe2=CreatePVectorFSViscousLATH(element); + ElementVector* pe3 = new ElementVector(pe,pe2); + delete pe; + delete pe2; + return pe3; + } + else if(fe_FS==LACrouzeixRaviartEnum){ + ElementVector* pe2=CreatePVectorFSViscousLACR(element); ElementVector* pe3 = new ElementVector(pe,pe2); delete pe; @@ -3674,4 +3814,17 @@ ElementVector* petemp =new ElementVector(pe1,pe2,pe3); ElementVector* pe4=CreatePVectorFSViscousLATH(element); + pe = new ElementVector(petemp,pe4); + delete pe1; + delete pe2; + delete pe3; + delete petemp; + delete pe4; + } + else if(fe_FS==LACrouzeixRaviartEnum){ + ElementVector* pe1=CreatePVectorFSViscous(element); + ElementVector* pe2=CreatePVectorFSShelf(element); + ElementVector* pe3=CreatePVectorFSFront(element); + ElementVector* petemp =new ElementVector(pe1,pe2,pe3); + ElementVector* pe4=CreatePVectorFSViscousLACR(element); pe = new ElementVector(petemp,pe4); delete pe1; @@ -3937,4 +4090,87 @@ }/*}}}*/ ElementVector* StressbalanceAnalysis::CreatePVectorFSViscousLATH(Element* element){/*{{{*/ + + int i,dim; + IssmDouble Jdet,r,pressure; + IssmDouble bed_normal[3]; + IssmDouble *xyz_list = NULL; + IssmDouble *xyz_list_base = NULL; + Gauss* gauss = NULL; + + /*Get problem dimension*/ + element->FindParam(&dim,DomainDimensionEnum); + + /*Fetch number of nodes and dof for this finite element*/ + int numnodes = element->GetNumberOfNodes(); + + /*Prepare coordinate system list*/ + int* cs_list = xNew(numnodes); + if(dim==2) for(i=0;iNewElementVector(FSvelocityEnum); + IssmDouble* dbasis = xNew(3*numnodes); + + /*Retrieve all inputs and parameters*/ + element->FindParam(&r,AugmentedLagrangianREnum); + element->GetVerticesCoordinates(&xyz_list); + + /*Get pressure and sigmann*/ + Input* pressure_input=element->GetInput(PressureEnum); _assert_(pressure_input); + Input* sigmann_input =element->GetInput(SigmaNNEnum); _assert_(sigmann_input); + + gauss=element->NewGauss(5); + for(int ig=gauss->begin();igend();ig++){ + gauss->GaussPoint(ig); + element->JacobianDeterminant(&Jdet,xyz_list,gauss); + + pressure_input->GetInputValue(&pressure, gauss); + element->NodalFunctionsDerivativesVelocity(dbasis,xyz_list,gauss); + + for(i=0;ivalues[i*dim+0] += pressure*gauss->weight*Jdet*dbasis[0*numnodes+i]; + pe->values[i*dim+1] += pressure*gauss->weight*Jdet*dbasis[1*numnodes+i]; + if(dim==3) pe->values[i*dim+2]+= pressure*gauss->weight*Jdet*dbasis[2*numnodes+i]; + } + } + + if(element->IsOnBase()){ + IssmDouble sigmann; + IssmDouble* vbasis = xNew(numnodes); + + element->GetVerticesCoordinatesBase(&xyz_list_base); + element->NormalBase(&bed_normal[0],xyz_list_base); + + delete gauss; + gauss=element->NewGaussBase(5); + for(int ig=gauss->begin();igend();ig++){ + gauss->GaussPoint(ig); + + element->JacobianDeterminantBase(&Jdet,xyz_list_base,gauss); + element->NodalFunctionsVelocity(vbasis,gauss); + sigmann_input->GetInputValue(&sigmann, gauss); + + for(i=0;ivalues[i*dim+0] += + sigmann*bed_normal[0]*gauss->weight*Jdet*vbasis[i]; + pe->values[i*dim+1] += + sigmann*bed_normal[1]*gauss->weight*Jdet*vbasis[i]; + if(dim==3) pe->values[i*dim+2] += + sigmann*bed_normal[2]*gauss->weight*Jdet*vbasis[i]; + } + } + xDelete(xyz_list_base); + xDelete(vbasis); + } + + /*Transform coordinate system*/ + //element->TransformLoadVectorCoord(pe,cs_list); Do not transform augmentation + + /*Clean up and return*/ + delete gauss; + xDelete(cs_list); + xDelete(xyz_list); + xDelete(dbasis); + return pe; +}/*}}}*/ +ElementVector* StressbalanceAnalysis::CreatePVectorFSViscousLACR(Element* element){/*{{{*/ int i,dim; Index: /issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.h (revision 18473) +++ /issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.h (revision 18474) @@ -70,4 +70,5 @@ ElementMatrix* CreateKMatrixFS(Element* element); ElementMatrix* CreateKMatrixFSViscousLATH(Element* element); + ElementMatrix* CreateKMatrixFSViscousLACR(Element* element); ElementMatrix* CreateKMatrixFSViscousXTH(Element* element); ElementMatrix* CreateKMatrixFSViscous(Element* element); @@ -77,4 +78,5 @@ ElementVector* CreatePVectorFSViscous(Element* element); ElementVector* CreatePVectorFSViscousLATH(Element* element); + ElementVector* CreatePVectorFSViscousLACR(Element* element); ElementVector* CreatePVectorFSViscousXTH(Element* element); ElementVector* CreatePVectorFSShelf(Element* element); Index: /issm/trunk-jpl/src/c/analyses/UzawaPressureAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/UzawaPressureAnalysis.cpp (revision 18473) +++ /issm/trunk-jpl/src/c/analyses/UzawaPressureAnalysis.cpp (revision 18474) @@ -17,6 +17,13 @@ /*Update elements: */ - int finiteelement = P1Enum; + int finiteelement; int counter=0; + int fe_FS; + + iomodel->Constant(&fe_FS,FlowequationFeFSEnum); + if(fe_FS=LATaylorHoodEnum) finiteelement = P1Enum; + else if(fe_FS=LACrouzeixRaviartEnum) finiteelement = P1DGEnum; + else _error_("solution not supported yet"); + for(int i=0;inumberofelements;i++){ if(iomodel->my_elements[i]){ @@ -35,5 +42,12 @@ void UzawaPressureAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/ - int finiteelement = P1Enum; + int finiteelement; + int fe_FS; + + iomodel->Constant(&fe_FS,FlowequationFeFSEnum); + if(fe_FS=LATaylorHoodEnum) finiteelement = P1Enum; + else if(fe_FS=LACrouzeixRaviartEnum) finiteelement = P1DGEnum; + else _error_("solution not supported yet"); + ::CreateNodes(nodes,iomodel,UzawaPressureAnalysisEnum,finiteelement); }/*}}}*/ @@ -176,5 +190,8 @@ /*Fetch number of nodes and dof for this finite element*/ int numnodes = element->GetNumberOfNodes(); - int numnodessigma = element->GetNumberOfNodes(P2Enum); + int numnodessigma; + if(element->element_type==P1Enum) numnodessigma=element->GetNumberOfNodes(P2Enum); + else if(element->element_type==P1DGEnum) numnodessigma=element->GetNumberOfNodes(P2Enum); + else _error_("finite element not supported yet"); element->FindParam(&dim,DomainDimensionEnum); Index: /issm/trunk-jpl/src/c/classes/Elements/Penta.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Penta.cpp (revision 18473) +++ /issm/trunk-jpl/src/c/classes/Elements/Penta.cpp (revision 18474) @@ -2417,4 +2417,27 @@ penta_node_ids[24]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofedges+iomodel->numberoffaces+iomodel->numberofelements+6*index+6; break; + case LACrouzeixRaviartEnum: + numnodes = 19; + penta_node_ids = xNew(numnodes); + penta_node_ids[ 0]=iomodel->nodecounter+iomodel->elements[6*index+0]; + penta_node_ids[ 1]=iomodel->nodecounter+iomodel->elements[6*index+1]; + penta_node_ids[ 2]=iomodel->nodecounter+iomodel->elements[6*index+2]; + penta_node_ids[ 3]=iomodel->nodecounter+iomodel->elements[6*index+3]; + penta_node_ids[ 4]=iomodel->nodecounter+iomodel->elements[6*index+4]; + penta_node_ids[ 5]=iomodel->nodecounter+iomodel->elements[6*index+5]; + penta_node_ids[ 6]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[9*index+0]+1; + penta_node_ids[ 7]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[9*index+1]+1; + penta_node_ids[ 8]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[9*index+2]+1; + penta_node_ids[ 9]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[9*index+3]+1; + penta_node_ids[10]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[9*index+4]+1; + penta_node_ids[11]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[9*index+5]+1; + penta_node_ids[12]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[9*index+6]+1; + penta_node_ids[13]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[9*index+7]+1; + penta_node_ids[14]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[9*index+8]+1; + penta_node_ids[15]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofedges+iomodel->elementtofaceconnectivity[5*index+2]+1; + penta_node_ids[16]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofedges+iomodel->elementtofaceconnectivity[5*index+3]+1; + penta_node_ids[17]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofedges+iomodel->elementtofaceconnectivity[5*index+4]+1; + penta_node_ids[18]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofedges+iomodel->numberoffaces+index+1; + break; default: _error_("Finite element "<nodecounter+iomodel->numberofvertices+iomodel->numberofedges+iomodel->numberofelements+3*index+3; break; + case LACrouzeixRaviartEnum: + numnodes = 7; + tria_node_ids = xNew(numnodes); + tria_node_ids[0]=iomodel->nodecounter+iomodel->elements[3*index+0]; + tria_node_ids[1]=iomodel->nodecounter+iomodel->elements[3*index+1]; + tria_node_ids[2]=iomodel->nodecounter+iomodel->elements[3*index+2]; + tria_node_ids[3]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[3*index+0]+1; + tria_node_ids[4]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[3*index+1]+1; + tria_node_ids[5]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[3*index+2]+1; + tria_node_ids[6]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofedges+index+1; + break; default: _error_("Finite element "<numberofvertices;i++){ + if(iomodel->my_vertices[i]){ + nodes->AddObject(new Node(id0+i+1,i,lid++,i,iomodel,analysis,FSvelocityEnum)); + } + } + for(i=0;inumberofedges;i++){ + if(my_edges[i]){ + nodes->AddObject(new Node(id0+iomodel->numberofvertices+i+1,iomodel->numberofvertices+i,lid++,0,iomodel,analysis,FSvelocityEnum)); + } + } + id0 = id0+iomodel->numberofvertices+iomodel->numberofedges; + if(iomodel->meshelementtype==PentaEnum){ + FacesPartitioning(&my_faces,iomodel); + for(i=0;inumberoffaces;i++){ + if(iomodel->faces[i*iomodel->facescols+2]==2){/*Vertical quads*/ + if(my_faces[i]){ + node = new Node(id0+i+1,iomodel->numberofvertices+iomodel->numberofedges+i,lid++,0,iomodel,analysis,FSvelocityEnum); + nodes->AddObject(node); + } + } + else if(iomodel->faces[i*iomodel->facescols+2]==1){/*Triangular base/top*/ + /*Nothing*/ + } + else{ + _error_("not supported"); + } + } + id0 = id0+iomodel->numberoffaces; + } + for(i=0;inumberofelements;i++){ + if(iomodel->my_elements[i]){ + nodes->AddObject(new Node(id0+i+1,id0-iomodel->nodecounter+i,lid++,0,iomodel,analysis,FSvelocityEnum)); + } + } + + /*No pressure*/ + break; default: Index: /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 18473) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 18474) @@ -609,4 +609,5 @@ OneLayerP4zEnum, CrouzeixRaviartEnum, + LACrouzeixRaviartEnum, /*}}}*/ /*Results{{{*/ Index: /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 18473) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 18474) @@ -598,4 +598,5 @@ case OneLayerP4zEnum : return "OneLayerP4z"; case CrouzeixRaviartEnum : return "CrouzeixRaviart"; + case LACrouzeixRaviartEnum : return "LACrouzeixRaviart"; case SaveResultsEnum : return "SaveResults"; case BoolExternalResultEnum : return "BoolExternalResult"; Index: /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 18473) +++ /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 18474) @@ -610,4 +610,5 @@ else if (strcmp(name,"OneLayerP4z")==0) return OneLayerP4zEnum; else if (strcmp(name,"CrouzeixRaviart")==0) return CrouzeixRaviartEnum; + else if (strcmp(name,"LACrouzeixRaviart")==0) return LACrouzeixRaviartEnum; else if (strcmp(name,"SaveResults")==0) return SaveResultsEnum; else if (strcmp(name,"BoolExternalResult")==0) return BoolExternalResultEnum; @@ -628,9 +629,9 @@ else if (strcmp(name,"MisfitModelEnum")==0) return MisfitModelEnumEnum; else if (strcmp(name,"MisfitObservation")==0) return MisfitObservationEnum; - else if (strcmp(name,"MisfitObservationEnum")==0) return MisfitObservationEnumEnum; else stage=6; } if(stage==6){ - if (strcmp(name,"MisfitTimeinterpolation")==0) return MisfitTimeinterpolationEnum; + if (strcmp(name,"MisfitObservationEnum")==0) return MisfitObservationEnumEnum; + else if (strcmp(name,"MisfitTimeinterpolation")==0) return MisfitTimeinterpolationEnum; else if (strcmp(name,"MisfitWeights")==0) return MisfitWeightsEnum; else if (strcmp(name,"MisfitWeightsEnum")==0) return MisfitWeightsEnumEnum;